구조
GOLDILOCKS LITE는 트랜잭션 기능을 탑재한 고성능의 shared memory 기반 데이터 관리 library로서의 성격을 가지고 있다.
GOLDILOCKS LITE의 특징은 다음과 같다.
별도의 관리 프로세스가 존재하지 않는 C/C++ library 형태의 direct attached 방식 데이터 관리
Shared memory 기반의 저장 공간 활용
Shared memory 공간 자동 확장과 최대 크기 제한 가능
하드웨어 장애 복구 및 안정성을 위해 disk logging 기법과 복구시간 단축을 위한 체크포인트 기능 제공
C 언어 기반의 직관적인 User-Interface API 제공
관리자를 위한 SQL syntax 제공
B+ tree 기반의 탐색 기반 제공
동시성 제어를 위한 row level locking 제공
Automatic deadlock detection 기능 제공
C 언어를 기준으로 설명하면, 다음과 같은 사용자 정의 struct 변수를 그대로 저장/ 조회/ 변경할 수 있도록 직관적인 동작 구조를 가지고 있다.
다음은 예제이다.
struct node
{
int mEmpNo;
char mEmpName[20];
int mDeptNo;
struct timeval mBirth
}위와 같은 C 구조체를 다음과 같은 테이블로 만들 수 있다.
create table node
(
empNo int,
empName char(20),
deptNo int,
birth date
)또한 쉬운 탐색을 위해 (empNo)에 index를 생성한다.
create unique index idx_node on node (empNo)
사용자는 application source code 내에서 다음과 같이 조작할 수 있다.
struct node xData; ... dbmInsertRow( Handle, "Node", &xData, sizeof(struct Node)); ... dbmSelectRow( Handle, "Node", &xData ); ...
GOLDILOCKS LITE는 위와 같은 C 언어의 structured data를 그대로 저장/ 조회하기 위해 제공되는 라이브러리이다. 다만, 이 데이터를 빠르게 탐색하기 위해 사용자가 구조체를 대신할 table/ index만 생성하고 그 외는 제공되는 API를 통해 데이터를 관리하는 내장 library로 정의할 수 있다.
Object
GOLDILOCKS LITE는 system 용도의 dictionary 및 사용자 명령에 의한 instance, table, index, queue, sequence 형태의 object를 생성할 수 있다. 각 object들은 트랜잭션을 처리하고 데이터를 저장하기 위한 물리적 공간을 갖는 단위 저장 공간이다.
모든 object 이름의 크기는 32 byte 이내로 제한된다.
DICTIONARY
Dictionary는 내부적으로 object의 정보를 관리하기 위한 공간으로 활용된다. 자세한 내용은 DICTIONARY를 참조한다.
INSTANCE
Instance는 다음과 같은 세 가지 저장 공간으로 사용된다. 한 개의 system 안에 N 개의 instance를 생성할 수 있는데 한 개의 instance는 다시 N 개의 하위 테이블을 가질 수 있는 구조로 동작한다.
저장 속성 | 설명 |
|---|---|
Session status | Instance 에 접근하는 모든 세션의 PID 등의 정보를 저장하는 공간이다. |
Transaction status | Session이 발생시키는 모든 트랜잭션의 상태 정보를 저장하는 공간이다. |
Rollback image | 트랜잭션에 의해 변경되기 전의 record image를 저장하는 공간이다. |
동시에 접속할 수 있는 세션의 최대 개수는 1024 개이다.
Instance는 그 특성상 rollback image를 저장하기 때문에 공간이 부족해질 수 있는데 이를 방지하기 위해 사용자가 1 M 단위로 instance 자동 확장 크기나 최대 크기를 지정하여 생성할 수 있다.
TABLE
테이블 이름은 한 개의 instance 안에서 고유해야 하며 테이블의 생성 개수에는 제한이 없다.
사용자의 데이터가 저장되는 공간이다.
테이블 공간은 생성 시점의 옵션에 따라 레코드 개수 단위로 자동 확장할 수 있고 최대 개수도 지정할 수 있다.
저장 가능한 레코드의 최대 크기는 999K 이다.
GOLDILOCKS LITE의 TABLE 개념은 C 기반의 structured data를 저장하기 위한 공간으로서 이는 다른 DBMS의 개념과 다르다. 즉, 사용자가 저장하는 C struct 변수를 테이블 형태로 저장하는 개념이다.
GOLDILOCK LITE는 다음과 같은 유형의 테이블들을 지원한다.
테이블 유형 | 설명 |
|---|---|
Normal table | B tree indexing을 가지는 테이블 형태이다. |
Direct table | 한 개의 column value 기반의 array table 형태이다. |
Splay table | Splay index로 구성되는 테이블 형태이다. |
Queue table | B tree 기반의 FIFO 방식 테이블이다. |
Sequence | Sequence object 이다. (Atomic 보장, non-transactional) |
Column 타입으로 지정할 수 있는 데이터 유형은 다음 표와 같다.
Column type | 설명 |
|---|---|
int | sizeof(int) |
short | sizeof(short) |
float | sizeof(float) (별도의 정밀도를 제공하지 않고 C type과 동일한 형태로 In/out) |
long | sizeof(long long) |
char (size) | Size |
double | sizeof(double) (별도의 정밀도를 제공하지 않고 C type과 동일한 형태로 In/out) |
date | sizeof(unsigned long) 8 bytes |
USER_TYPE | USER TYPE으로 생성한 타입을 column으로 지정 |
INDEX
데이터는 테이블에 순차적으로 저장되지만 사용자가 검색에 필요한 index를 생성할 수도 있다. Index는 B tree를 기반으로 구축되며 별도로 크기를 지정하는 것이 아니라 index가 속한 테이블 크기에 따라 계산된 크기로 생성된다.
Index key column으로 지정할 수 있는 데이터 유형은 short, int, long, char type이며 한 개 이상의 composite key를 구성하거나 동일한 테이블에 대해 N개의 index를 생성할 수 있다.
DIRECT TABLE
사용자의 특정 column 한 개를 key로 지정하여 그 값을 테이블의 레코드 위치로 변환하여 저장한다. 즉, 일종의 array 타입 저장구조를 가지고 있다. Key로 지정할 수 있는 column 타입은 long, short, int 뿐이다. 만일 key 값이 테이블의 전체 개수보다 클 경우에는 modular 연산을 통해 나머지 값을 key로 지정하고 그 위치에 해당하는 테이블스페이스에 저장한다.
예를 들어, 최대 크기를 100 만개로 지정하고 key 값을 1049로 입력하면 1049 번째 tablespace 위치에 사용자 데이터가 저장된다. 또는 값이 1049000 일 경우, modular 연산을 통해 나온 나머지인 49000 번째 위치에 저장된다. 이 때, 해당 위치에 어떤 값이 이미 저장되어 있는 상태일 경우 duplicated error가 발생한다.
Direct table은 한 개의 key만 지정할 수 있기 때문에 index는 반드시 unique 타입으로 생성해야하며 테이블 하나당 한 개의 unique index만 생성할 수 있다.
SPLAY TABLE
Splay table은 key를 기준으로 별도의 index segment 없이 table segment 내에서 splay indexing으로 정렬되는 테이블이다. 해당 테이블은 최근 조회/ 조작한 데이터 근처의 데이터를 빠르게 탐색해야 하는 업무에 특화된 테이블 기능이다.
QUEUE
사용자의 데이터를 First-In/First-Out (FIFO) 방식으로 저장하고 조회하는 저장소 역할을 수행한다. Queue table은 B tree 기반의 index를 자동으로 설정하여 MsgType나 priority 등을 사용자가 조작할 수 있도록 지원한다.
Dequeue 동작은 트랜잭션 개념에서 차이가 있다. 예를 들어, 데이터가 (1, 2, 3) 순으로 queue에 저장되어 있을 때 A 세션이 1을 dequeue 하고 아직 커밋하기 전이라도 다른 B 세션은 2라는 데이터를 dequeue 할 수 있다. 즉, A가 커밋할 때까지 기다리지 않는다. Dequeue 동작은 delete와 달리 어떠한 세션에서도 접근하지 않은 데이터를 가져오는 방식으로 동작한다.
동일한 테이블의 다양한 MsgType과 priority를 지원하지만 경합이 빈번할 경우 성능이 저하될 수 있다. 따라서 가능한 응용 프로그램에서 N개의 다양한 queue table을 생성하여 목적에 맞게 분산하여 사용할 것을 권장한다.
SEQUENCE
사용자가 sequence 객체로 지정한 start 값부터 increment 값에 지정된 크기만큼 atomic 하게 증가된 값을 반환한다.
Sequence 객체는 트랜잭션을 지원하지 않기 때문에 standby로 전환될 경우, 각 sequence 객체의 current value를 변경해야 데이터 중복 등을 방지할 수 있다.
동시성 제어
Row Level Locking
GOLDILOCKS LITE는 row level locking을 제공한다. 즉, 최소 lock 대기 지점이 항상 row level에서 발생한다. 따라서 동일한 테이블에서 다수의 session이 서로 다른 row에 접근하더라도 배타적으로 상호 보호할 수 있다. 또한, dead lock을 auto detection 하기 때문에 교착 상태에 빠지는 것을 방지한다.
Undo Space
Session은 갱신 작업을 수행하기 전에 갱신할 image를 별도의 공간 (instance undo space)에 저장한다. 이 때 접근하는 조회 session이 갱신 트랜잭션을 기다리지 않고 이전에 commit 된 image를 읽을 수 있도록 동시성을 제공한다.
Auto Dead Lock Detection
갱신 연산끼리 서로 대기하는 상황이 발생할 수 있다. 예를 들어 T1 (A, B) 레코드가 존재할 때 session 1은 A를 갱신한 후에 B를 갱신하려고 시도하는 반면에 session 2는 B를 갱신한 후에 A를 변경하려고 시도할 경우, session 1과 session 2는 서로 교착상태에 빠지게 된다. 이런 상황을 자동으로 감지하고 session ID가 큰 쪽에서 오류가 발생하도록 하여 교착 상태를 해제한다.
Delayed Recovery Concept
Delayed recovery는 GOLDILOCKS LITE에 존재하는 실시간 비정상 종료 트랜잭션에 대한 복구 매커니즘이다.
GOLDILOCKS LITE의 in-memory mode 환경에는 별도의 daemon process가 존재하지 않는다. 따라서 사용자 응용 프로그램이 트랜잭션을 수행하는 도중에 commit/ rollback 과정 없이 비정상적으로 종료될 경우에 이를 감지하고 복구하는 일련의 과정을 수행해야 하는데 이를 delayed recovery 라고 한다.
Delayed recovery는 다음과 같이 수행된다.
모든 세션은 접속 과정에서 instance transaction 공간에 자신의 고유공간을 할당받는다
여기에는 자신의 PID, TID와 같은 process 정보와 해당 공간이 점유되었음을 알리는 정보를 남긴다.
모든 세션은 record에 lock을 점유할 때 자신의 고유 ID (Transaction ID)를 기록한다.
이후 트랜잭션 과정에서 lock을 점유해야 할 경우, 나중에 진입한 세션은 위의 방식을 통해 다음의 두 가지 정보에 접근할 수 있다.
Lock을 점유한 세션 (transaction ID)
Instance transaction 공간을 통해 lock을 점유한 세션이 alive 한지 여부
위의 방식을 통해 비정상 종료가 감지된 세션은 다음 과정을 통해 복구된다.
비정상 종료된 세션의 instance transaction 공간에 대한 lock (복구 작업이 동시에 개시되는 것을 방지)
비정상 종료된 세션이 기록한 transaction log를 바탕으로 데이터 복구, lock 해제, 자원 해제
Instance transaction 공간 해제 및 재사용 공간으로 전환
자신의 트랜잭션 개시
복구가 불가능한 경우 사용자에게 에러 메세지를 보여주고 대상 테이블을 refine 처리하여 복구하는 방안을 제공한다.
Quick Start
GOLDILOCKS LITE의 설치와 간단한 사용법에 대해 기술한다.
설치 전 작업
Posix 방식의 shared memory를 관리하므로 /dev/shm에 충분한 공간을 설정해야 한다.
Shared memory 커널 파라미터를 설정해야 한다.
Semaphore 커널 파라미터를 설정해야 한다.
Shared Memory 커널 파라미터
[lim272@localhost test]$ ipcs -lm ------ Shared Memory Limits -------- max number of segments = 4096 max seg size (kbytes) = 18014398509465599 max total shared memory (kbytes) = 18014398442373116 min seg size (bytes) = 1
다음과 같이 커널 속성을 변경한 후에 reboot 또는 sysctl -p 하여 반영할 수 있다.
[lim272@localhost test]$ vi /etc/sysctl.conf ######################################## kernel.shmmax = (실제 메모리 크기: byte 단위) kernel.shmall = (실제 메모리 크기: byte 단위) kernel.shmmni = (segment의 총 개수) ########################################
하나의 프로세스 내에서 multi threads로 많은 세션을 가져가는 구조에서는 vm.map_max_count가 65536이면 부족하기 때문에 필요할 경우 262144 정도로 늘려야 한다.
기타
Redhat, Ubuntu와 같은 리눅스 기반 시스템의 systemd가 관리하는 세션 목록에서 IPC 자원 생성 사용자가 로그아웃하면 해당 IPC 자원이 자동 삭제되는 옵션이 추가되었다. 따라서 다음과 같이 시스템을 설정해 주어야 세마포어가 삭제되는 것을 방지할 수 있다. (커널 3.0.0 이상)
# cp -i /etc/systemd/logind.conf /etc/systemd/logind.conf_prev # cat /etc/systemd/logind.conf [Login] #NAutoVTs=6 #ReserveVT=6 ... RemoveIPC=no
수정한 후에 수행한다.
# systemctl restart systemd-login
환경 변수
GOLDILOCKS LITE를 사용하려면 사용자가 $DBM_HOME/conf/dbm.cfg를 설정하거나 터미널 환경변수를 설정해야 한다. 환경 변수는 각각 다음과 같이 설정한다.
환경변수 이름 | 설명 |
|---|---|
DBM_HOME | DBM이 설치된 경로이다. |
DBM_INSTANCE | 사용할 Default Instance Name을 지정한다. |
PATH | $DBM_HOME/bin 을 추가한다. |
LD_LIBRARY_PATH | $DBM_HOME/lib 를 추가한다. |
DBM_DISK_LOG_ENABLE | DISK mode를 사용할 경우 1로 설정한다. |
DBM_DISK_LOG_DIR | DISK mode를 사용할 경우 logfile이 저장될 경로를 지정한다. |
DBM_DISK_LOG_FILE_SIZE | 기본 100 M로 설정되며 로그 파일의 크기를 지정한다. |
DBM_DISK_DATA_FILE_DIR | DISK mode에서 CheckPoint를 수행할 때 생성될 데이터 파일이 저장될 경로를 지정한다. |
DBM_LISTEN_PORT | dbmListener를 이용하여 원격으로 접속할 때 사용할 port를 지정한다. |
DBM_LISTEN_CONN_TIMEOUT | 원격 접속 연결 시점의 timeout 시간을 설정한다. (millisecond 단위) |
DBM_LISTEN_RECV_TIMEOUT | 원격 접속 전송 후에 ack 수신을 기다리는 시간을 설정한다. (millisecond 단위) |
DBM_LOG_CACHE_MODE | Log cache 모드를 설정한다.
|
DBM_LOG_CACHE_SIZE | Log cache 크기를 지정한다. (하나의 NVDIMM 또는 shared memory 크기) DBM_DISK_LOG_FILE_SIZE보다 두 배 이상 커야 한다. (Log cache에 DBM_DISK_LOG_FILE_SIZE 이상의 데이터가 있을 때 파일로 저장됨) |
DBM_LOG_CACHE_FLUSH_INTERVAL | Log cache가 log file로 flush 되는 interval 이다. (millisecond 단위) (Log cache가 log file 크기에 도달하면 flush 되는데 그 크기가 되기 전이라도 여기에 설정된 interval이 지나면 flush 된다.) |
DBM_LOG_CACHE_EMPTY_INTERVAL | Log cache를 skip 하는 interval 이다. (millisecond 단위) (Log cache를 사용하는 도중에 죽은 경우를 interval로 판단하여 log를 skip 한다.) |
DBM_DISK_COMMIT_WAIT | Commit 할 때 redo 파일이 손실되지 않도록 파일에 완전히 쓰여질 때까지 기다리는 모드를 설정한다. |
DBM_ARCHIVE_ENABLE | Redo 로그를 archive로 저장하도록 설정한다. |
DBM_ARCHIVE_PATH | Redo 로그를 archive로 저장하는 디렉토리를 설정한다. |
DBM_REPL_ENABLE | 이중화 동작 여부를 설정한다. (1: 이중화 모드) |
DBM_REPL_ASYNC_DML | Async 이중화 동작 여부를 설정한다 (1: async) |
DBM_REPL_TARGET_PRIMARY_IP | Sender 측에서 slave에 대한 IP를 설정한다. (예: 127.0.0.1) |
DBM_REPL_TARGET_PORT | Sender 측에서 slave의 dbmReplica의 listen port를 설정한다. |
DBM_REPL_LISTEN_PORT | Slave 측 dbmReplica의 listen port를 설정한다. |
DBM_REPL_CONN_TIMEOUT | 세션을 초기 구동하면서 이중화 연결을 시도할 때 timeout을 지정한다. (단위: millisecond) |
DBM_REPL_RECV_TIMEOUT | 이중화 동작 중에 여기 설정된 시간 동안 Recv packet이 수신되지 않으면 오류로 처리한다. (단위: millisecond) |
DBM_REPL_UNSENT_LOG_DIR | 이중화 라인이 단절될 경우 미전송 로그를 쌓을 디렉토리를 지정한다. |
DBM_REPL_UNSENT_LOGFILE_SIZE | 미전송 로그를 쌓을 경우 1개 파일의 최대 크기를 지정한다. |
DBM_ODBC_DRIVER_PATH | load/ sync 구문을 사용하기 위해 설치한 unix odbc driver manager의 library 경로를 지정한다. (이 환경변수가 설정되지 않으면 load/ sync 구문이 작동하지 않는다.) |
DBM_SHM_PREFIX | 이 속성에 설정된대로 /dev/shm의 하위 디렉토리에 shared memory segment를 생성할 경우 그 이름을 고유하게 설정한다. |
DBM_SHM_DIR | /dev/shm 하위에 디렉토리를 생성할지 여부이다. 최신 linux 커널은 디렉토리를 생성할 수 없다. |
DBM_LOG_CACHE 설정, DIRECTORY 경로 설정, FILE-SIZE와 관련된 사항은 create instance 작업이 수행된 이후에는 프로퍼티를 통해 변경할 수 없으므로 신중하게 설정해야 한다.
다음은 bash 환경에서 환경 변수를 설정하는 예이다.
GOLDILOCKS LITE 기본 설정
export DBM_HOME=/home/lim272/dbm_home
export PATH=${DBM_HOME}/bin:$PATH:.
export LD_LIBRARY_PATH=${DBM_HOME}/lib:$LD_LIBRARY_PATH:.DBM DISK LOG
#export DBM_DISK_LOG_ENABLE=1
#export DBM_DISK_LOG_DIR=${DBM_HOME}/wal
#export DBM_DISK_DATA_FILE_DIR=${DBM_HOME}/dbf설치 및 라이센스
본 절에서는 설치 방법과 라이센스 발급에 관한 내용을 기술한다.
설치
설치파일은 보통 다음과 같은 압축파일로 제공되기 때문에 사용자가 설정한 $DBM_HOME 경로에서 압축을 해제하면 설치가 완료된다.
goldilocks_A.B.C.tar.gz <A> : Major Version <B,C> : Patch Version
shell> gzip -dc goldilocks_3.1.1.tar.gz | tar xvf -
압축을 해제한 후 설치된 각 경로에 대한 설명은 다음과 같다.
경로 이름 | 설명 |
|---|---|
arch | Archive log가 저장되는 경로이다. |
bin | dbmMetaManager를 포함한 각종 유틸리티 바이너리의 집합이다. |
lib | API shared library 위치이다. |
include | API header 파일 위치이다. |
trc | Trace log가 저장되는 경로이다. |
sample | API를 이용한 demo code 이다. |
conf | dbm.cfg와 dbm.license 파일이 위치하는 곳이다. |
dbf | Data file이 저장되는 경로이다. |
repl | not used (reserved) |
wal | Redo log가 저장되는 경로이다. |
bin 디렉토리의 각 binary는 각각 다음과 같은 기능을 수행한다.
Binary 이름 | 설명 |
|---|---|
dbmMetaManager | DDL/ DML을 수행하는 interactive tool 이다. |
dbmListener | 원격 접속을 가능하게 하는 데몬 tool 이다. |
dbmLogFlusher | LogCache를 사용하는 경우 LogCache를 파일로 flush하는 tool이다. |
dbmMonitor | 현재 DB 상태를 모니터링 하는 tool 이다. |
dbmExp | DDL script와 데이터를 추출하는 tool 이다. |
dbmImp | 저장된 파일의 데이터를 구분자를 가진 plain text로 load하는 tool 이다. |
dbmErrorMsg | Error code를 출력하는 tool 이다. |
dbmCkpt | DISK mode에서 logfile을 이용하여 데이터 파일을 생성하고 불필요한 logfile을 삭제하는 tool 이다. |
dbmReplica | 이중화 운영모드인 경우 Slave에서 데이터를 수신/처리하는 프로세스이다. |
dbmDump | 세그먼트와 파일을 추적하는 tool이다. 트랜잭션, 테이블, 인덱스, 데이터 파일, 로그 파일, anchor 파일 등의 이상 유무를 추적한다. |
라이센스
별도의 테스트 라이센스를 포함하고 있지 않기 때문에 technet@sunjesoft.com 메일로 테스트 장비의 hostid를 기록하여 라이센스를 요청해야 한다.
시작하기
설치가 완료되고 환경변수 설정도 끝났다면 dbmMetaManager를 구동하여 사용을 시작할 수 있다. 다음과 같이 dictionary instance를 생성하여 사용을 준비한다.
[lim272@localhost 4th_iter]$ dbmMetaManager *********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> initdb; success
다음과 같이 사용자 instance를 생성한다. Dictionary instance에 접속한 상태에서만 instance를 생성할 수 있다. Dictionary instance 이름은 dict로 고정되어 있다.
dbmMetaManager(unknown)> set instance dict; success dbmMetaManager(DICT)> create instance demo; success dbmMetaManager(DICT)> set instance demo; success dbmMetaManager(DEMO)>
다음과 같이 사용자의 table과 index를 생성하여 실제로 데이터를 조작할 수 있는 상태로 만든다.
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int); success dbmMetaManager(DEMO)> create unique index idx_t1 on t1 (c1); success dbmMetaManager(DEMO)> insert into t1 values (1, 1); success dbmMetaManager(DEMO)> commit; success dbmMetaManager(DEMO)> update t1 set c2 = 100 where c1 = 1; 1 row updated. dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 100 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> delete from t1; 1 row deleted. dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- 0 row selected dbmMetaManager(DEMO)> rollback; success dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 1 --------------------------------------------------------------------------------- 1 row selected
구문
API와 dbmMetaManager에서 사용할 각 구문들을 기술한다.
DDL
Instance, table, index 등과 같은 각 object 들을 생성하고 제거하는 구문들이다. DDL에 사용되는 각 object의 이름의 크기는 최대 32 byte로 제한되며 반드시 문자로 시작해야 한다.
Table (또는 direct table)을 생성할 때 column의 최대 크기는 1048332 byte이다. Window type table을 생성할 때 data의 최대 크기는 1048328 byte이다. Queue를 생성할 때 message의 최대 크기는 1048296 byte이다. Index를 생성할 때 column의 최대 크기는 1024 byte 이다.
DDL이 수행될 때면 항상 instance lock이 잡히는데 이 때문에 이 시점에 시작되는 트랜잭션들은 대기하게 된다. 따라서 모든 세션들을 종료한 후에 DDL을 수행할 것을 권장한다.
DDL을 수행할 때 이전에 수행했던 트랜잭션이 존재할 경우, 오류가 발생하므로 이전에 수행한 트랜잭션을 commit/ rollback 한 후에 실행해야 한다.
initdb
기능
최초로 설치한 후에 dictionary instance를 생성하기 위해 수행한다. 수행하지 않을 경우 사용할 수 없다. 생성된 dictionary instance의 이름은 DICT 이고 set instance 구문을 통해 접근할 수 있다.
구문
<initdb> ::= initdb
;사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> initdb; success dbmMetaManager(unknown)>
create instance
기능
사용자가 session/ undo space로 사용할 instance object를 생성한다. Dictionary instance (DICT)에 접속한 상태에서만 instance를 생성하거나 제거할 수 있다.
구문
<create instance> ::= CREATE INSTANCE instance_name
[ init <size> ]
[ extend <size> ]
[ max <size> ]
;instance_name: 사용자 지정 이름
init <size>: 최초로 할당할 공간 크기를 지정 (한 개당 size 단위는 32K 이다.)
extend <size>: init 공간이 모두 사용되어 max까지 확장될 때의 크기
max <size>: 최대로 확장할 수 있는 instance 크기
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> set instance dict; success dbmMetaManager(DICT)> create instance demo init 1024 extend 1024 max 10240; success
create table
기능
사용자가 데이터를 저장할 테이블을 생성한다. 테이블은 instance의 하위 개념이기 때문에 생성될 테이블의 instance에 먼저 접근해야 한다. Dictionary instance에는 사용자가 테이블을 생성할 수 없다.
구문
<create table> ::= CREATE [TABLE_TYPE] table_name [ SIZE int_val ]
(
column_definition [, ...]
)
[ init <size> ]
[ extend <size> ]
[ max <size> ]
;• TABLE_TYPE ::= TABLE
| DIRECT
| SPAY
• table_name: 사용자 지정 테이블 이름이다.
• SIZE int_val ::= WINDOW TYPE 테이블을 생성할 때만 최대 저장길이를 명시한다.
• column_definition ::= column_name data_type_definition
• column_name: 사용자 지정 column 이름이다.
• data_type_definition ::= short
| int
| long
| float
| double
| char (size)
| date
| USER_TYPE <TypeName>
• init <size>: 최초로 할당될 공간 크기를 지정한다. (Size 단위 하나당 row 하나를 갖는다.)
• extend <size>: init 공간이 모두 사용되어 max까지 확장될 때의 크기이다.
• max <size>: 최대로 확장할 수 있는 row 개수이다.
• USER_TYPE <TypeName> : TypeName은 미리 생성한 사용자 지정 타입의 이름이다.GOLDILOCKS LITE의 data type은 C 언어의 변수 개념과 유사하다. 다음 크기를 고려하여 사용자 정의 변수를 사용할 경우, offset 위치를 동일하게 사용할 수 있다.
Data type | C type과 크기 (64 bit OS 기준) |
|---|---|
short | short과 같으며 2 byte 이다. |
int | int와 같으며 4 byte 이다. |
long | long을 의미하며 8 byte 이다. |
float | 4 byte 이다. |
double | 8 byte 이다. |
char | char와 같으며 사용자가 지정한 크기만큼 설정된다. (실제 크기는 c의 struct 구조와 동일하게 할당된다.) |
date | 8 byte이며 사용자 구조체의 멤버 변수는 unsigned long으로 선언해야 한다. |
USER_TYPE | 사용자가 생성한 타입으로 column 타입을 지정 |
각 column의 offset은 c 언어의 struct와 동일하게 alignment 된다.
사용 예
***********************************************************
* Copyright © 2010 SUNJESOFT Inc. All rights reserved.
***********************************************************
dbmMetaManager(DICT)> set instance demo;
success
dbmMetaManager(DEMO)> create table t1
2 (
3 c1 short,
4 c2 int,
5 c3 long,
6 c4 float,
7 c5 double,
8 c6 char(20),
9 c7 date
10 );
success
dbmMetaManager(DEMO)> desc t1;
-------------------------------------------------------------------------------------
Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(64)
-------------------------------------------------------------------------------------
C1 short 2 0
C2 int 4 4
C3 long 8 8
C4 float 4 16
C5 double 8 24
C6 char 20 32
C7 date 8 56
-------------------------------------------------------------------------------------
Any index not created
-------------------------------------------------------------------------------------
success다음은 사용자 타입을 지정하는 예이다.
dbmMetaManager(DEMO)> CREATE USER_TYPE u2 ( c1 INT, c2 LONG ); success dbmMetaManager(DEMO)> CREATE TABKE t2 (c1 LONG, c2 INT, c3 USER_TYPE u2 ) success dbmMetaManager(DEMO)> DESC t2 ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T2) Type=(TABLE) RowSize=(32) LockMode(1) ------------------------------------------------------------------------------------- C1 long 8 0 C2 int 4 8 C3 U2 16 16 ------------------------------------------------------------------------------------- Any index not created ------------------------------------------------------------------------------------- success
create index
기능
사용자가 지정한 테이블에 속한 B-tree index를 생성한다. 최대로 생성할 수 있는 index의 개수에는 제한이 없지만 index key column이 중복될 경우에는 생성할 수 없고 key column size의 합이 1024 byte를 넘는 경우에도 생성할 수 없다. Index key column으로는 int, short, long, char 네 가지 데이터 타입 column만 허용된다.
구문
<create index> ::= CREATE [UNIQUE] INDEX index_name ON table_name
( column_name [, ... ] )
;index_name: 사용자 지정 index 이름
table_name: Index를 생성할 대상 table 이름
column_name: Key column으로 사용될 column 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> create unique index idx1_t1 on t1 (c1); success dbmMetaManager(DEMO)> create index idx2_t1 on t1 (c1, c2); success dbmMetaManager(DEMO)> desc t1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(64) ------------------------------------------------------------------------------------- C1 short 2 0 C2 int 4 4 C3 long 8 8 C4 float 4 16 C5 double 8 24 C6 char 20 32 C7 date 8 56 ------------------------------------------------------------------------------------- IDX1_T1 unique (C1) IDX2_T1 (C1, C2) ------------------------------------------------------------------------------------- success
USER_TYPE으로 지정된 column은 index column으로 지정할 수 없다.
create queue
기능
First-In/ First-Out (FIFO) 동작을 하는 queue 형태 테이블을 생성한다.
구문
<create queue> ::= CREATE QUEUE queue_name SIZE msg_size
[ init <size> ]
[ extend <size> ]
[ max <size> ]
;queue_name: 대상 queue table 이름
msg_size: 테이블에 저장될 메시지의 최대 크기
init <size>: 최초로 할당될 공간 크기를 지정한다. (Size 단위 하나당 row 하나를 갖는다.)
extend <size>: init 공간이 모두 사용되어 max까지 확장될 때의 크기이다
max <size>: 최대로 확장할 수 있는 row의 개수이다.
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> create queue que1 size 1024; success dbmMetaManager(DEMO)> desc que1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(QUE1) Type=(QUEUE) RowSize=(1056) ------------------------------------------------------------------------------------- MSG_TYPE int 4 0 PRIORITY int 4 4 ID long 8 8 MSG_SIZE int 4 16 IN_TIME date 8 24 MESSAGE char 1024 32 ------------------------------------------------------------------------------------- IDX_QUE1 unique (MSG_TYPE, PRIORITY, ID) ------------------------------------------------------------------------------------- success
Enqueue로 삽입된 데이터는 커밋된 이후 조회하거나 dequeue 할 수 있고 enqueue한 세션 역시 commit 한 후에 dequeue 할 수 있다.
Dequeue로 한 건을 가져온 이후 commit 하지 않는 세션이 존재하더라도 다른 dequeue를 수행하는 세션이 이를 기다리지 않고 다른 데이터를 dequeue하도록 동작한다.
Dequeue한 데이터를 rollback 할 경우, 가장 앞쪽으로 다시 재삽입된다.
Queue를 생성할 때 메시지 크기는 사용자 입력값을 8 byte로 align 하여 생성한다. 따라서 사용자 버퍼를 설정할 때는 테이블 생성 후의 크기를 확인하여 주의해서 할당해야 한다.
Queue 테이블은 내부적으로 생성 시점에 자동으로 index를 생성하는데 이는 사용자가 변경할 수 없다.
create sequence
기능
Sequence 객체를 생성한다. 다른 DBMS와는 달리 별도로 로깅을 수행하지 않으므로 필요한 경우 사용자가 dbmExp 등을 활용하여 직접 백업해야 한다. nextval, currval 함수를 제공하므로 해당 값을 이용하여 alter sequence 구문을 통해 변경할 수도 있다.
구문
<create sequence> ::= CREATE SEQUENCE sequence_name [options]
;
<options> ::= START WITH <value>
| INCREMENT BY <value>
| MAXVALUE <value>
| MINVALUE <value>
| CYCLE | NOCYCLEsequence_name: Sequence 이름
Sequence 생성 시점의 각 옵션들은 생략할 수 있다.
<START WITH>에 설정된 값은 <MAXVALUE>를 초과하여 생성할 수 없다.
<INCREMENT BY>를 생략할 경우 default는 1로 설정된다.
<MINVALUE>를 생략할 경우 default는 0으로 설정된다.
<MAXVALUE>를 생략할 경우 default는 LONG_MAX 값으로 설정된다.
<CYCLE> 옵션을 지정했을 때 sequence의 current value가 MaxValue를 넘어서면 MinValue로 설정된다.
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> create sequence seq1 start with 10 increment by 1 maxvalue 100 cycle; success dbmMetaManager(DEMO)> select seq1.nextval from dual; --------------------------------------------------------------------------------- NEXTVAL : 11 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select seq1.currval from dual; --------------------------------------------------------------------------------- CURRVAL : 11 --------------------------------------------------------------------------------- 1 row selected
Sequence는 로깅 및 이중화 대상이 아니므로 복구 후에 사용자가 해당 값을 새롭게 세팅해야 한다.
drop index
기능
지정된 index를 제거한다.
구문
<drop index> ::= DROP INDEX index_name
;index_name: 제거 대상 index의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> desc t1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(64) ------------------------------------------------------------------------------------- C1 short 2 0 C2 int 4 4 C3 long 8 8 C4 float 4 16 C5 double 8 24 C6 char 20 32 C7 date 8 56 ------------------------------------------------------------------------------------- IDX1_T1 unique (C1) IDX2_T1 (C1, C2) ------------------------------------------------------------------------------------- success dbmMetaManager(DEMO)> drop index idx2_t1; success dbmMetaManager(DEMO)> desc t1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(64) ------------------------------------------------------------------------------------- C1 short 2 0 C2 int 4 4 C3 long 8 8 C4 float 4 16 C5 double 8 24 C6 char 20 32 C7 date 8 56 ------------------------------------------------------------------------------------- IDX1_T1 unique (C1) ------------------------------------------------------------------------------------- success
Direct type과 queue table에 생성된 index는 사용자가 삭제할 수 없으며 삭제하려고 할 경우 다음과 같은 오류가 발생한다.
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> drop index IDX_QUE1; Command] <drop index IDX_QUE1> ERR-102012] fail to prepare a statement ERR-102047] a operation can not be executed on target-table (check table type) dbmMetaManager(DEMO)>
drop table (queue)
기능
사용자가 지정한 table (queue)과 해당 object에 생성된 하위 index object를 모두 제거한다.
구문
<drop table> ::= DROP TABLE table_name
|
DROP QUEUE table_name
;table_name: 제거 대상 table (queue)의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> desc t1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(64) ------------------------------------------------------------------------------------- C1 short 2 0 C2 int 4 4 C3 long 8 8 C4 float 4 16 C5 double 8 24 C6 char 20 32 C7 date 8 56 ------------------------------------------------------------------------------------- IDX1_T1 unique (C1) IDX2_T1 (C1, C2) ------------------------------------------------------------------------------------- success dbmMetaManager(DEMO)> drop table t1; success dbmMetaManager(DEMO)>
drop sequence
기능
사용자가 지정한 sequence object를 제거한다.
구문
<drop table> ::= DROP SEQUENCE <sequence_name>
;sequence_name: 제거 대상 sequence의 이름
사용 예
dbmMetaManager(DEMO)> drop sequence seq10; success
drop instance
기능
사용자가 지정한 instance와 모든 하위 table, index object를 제거한다. Dictionary instance (dict)에 접근한 후에 이 구문을 수행해야 한다.
구문
<drop instance> ::= DROP INSTANCE instance_name
;instance_name: 제거 대상 instance의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> set instance dict; success dbmMetaManager(DICT)> drop instance demo; success dbmMetaManager(DICT)> set instance demo; ERR-0] a handle of dbmMetaManager not initialized Command] <set instance demo>
truncate table (Queue)
기능
사용자가 지정한 테이블을 초기화한다. 테이블 내의 데이터와 extend 된 segment는 모두 제거되고 테이블 생성 시점에 지정된 init size로 재생성된다.
구문
<truncate table> ::= TRUNCATE TABLE table_name
|
TRUNCATE QUEUE table_name
;table_name: Truncate 할 table의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> set instance demo; success dbmMetaManager(DEMO)> truncate table t1; success
compact table
기능
사용자가 지정한 테이블에 대해 compaction을 수행한다. 삽입/삭제가 반복되면 늘어난 segment 자체는 OS로 반납할 수 없다. 따라서 이 구문은 segment의 공간을 줄이고자 할 경우에 사용한다.
이 명령은 내부적으로 데이터 export → truncate → 데이터 import 과정을 수행하기 때문에 application들이 접속된 상태에서 동작할 경우 오류가 발생할 수 있으므로 application을 모두 종료한 후 수행해야 한다.
구문
<compact table> ::= ALTER TABLE table_name COMPACT
;table_name: Compact 할 table의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> set instance demo; success dbmMetaManager(DEMO)> ALTER TABLE t1 COMPACT; success
add column
기능
사용자가 테이블에 column을 추가할 경우에 사용한다. 위치를 지정할 수 없으며 항상 마지막 column으로 추가된다. add column 기능은 메모리 모드이면서 일반 테이블 타입인 경우에만 사용할 수 있다.
이 명령은 내부적으로 데이터 export → 테이블 재생성 → 데이터 import 과정을 수행하기 때문에 application들이 접속된 상태에서 동작할 경우 오류가 발생할 수 있으므로 application을 모두 종료한 후에 수행해야 한다.
구문
<add column> ::= ALTER TABLE table_name ADD COLUMN ( column_name datatype [default_value] )
;table_name: Column을 추가할 table의 이름
column_name: 추가할 column의 이름
datatype: Column의 데이터 타입 이름 (int, short, long, date, char, float, double)
default_value: date type을 제외한 데이터 타입의 기본값을 지정할 경우에 정의한다. (상수만 허용)
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 > 0 --------------------------------------------------------------------------------- C1 : 1 C2 : a C3 : 1 C4 : a --------------------------------------------------------------------------------- C1 : 2 C2 : b C3 : 2 C4 : b --------------------------------------------------------------------------------- C1 : 3 C2 : c C3 : 3 C4 : c --------------------------------------------------------------------------------- 3 row selected dbmMetaManager(DEMO)> alter table t1 add column (c5 char(10) default 'zz' ) success dbmMetaManager(DEMO)> select * from t1 where c1 > 0 --------------------------------------------------------------------------------- C1 : 1 C2 : a C3 : 1 C4 : a C5 : zz --------------------------------------------------------------------------------- C1 : 2 C2 : b C3 : 2 C4 : b C5 : zz --------------------------------------------------------------------------------- C1 : 3 C2 : c C3 : 3 C4 : c C5 : zz --------------------------------------------------------------------------------- 3 row selected
데이터 건수에 따라 수행 완료까지 소요되는 시간이 길어질 수 있다.
add column 구문이 동작하는 도중에 오류로 인해 복구가 필요한 경우에는 별도의 dbmMetaManager에 새롭게 접속하면 add column 작업에 대한 복구를 수행하여 원래의 상태로 복구할 수 있다.
그러나 알 수 없는 원인으로 자동 복구되지 않을 경우에는 add column 수행 시점에 백업된 데이터를 이용해 수동으로 복구할 수 있다.
백업 데이터는 $DBM_HOME/trc 경로에 table 이름과 SCN 정보를 기반으로 데이터 파일로 생성된다. 이 파일은 dbmImp가 binary 모드로 인식할 수 있는 파일이므로 새롭게 테이블을 생성한 후에 다음과 같은 명령으로 데이터를 복구할 수 있다.
dbmImp -i demo -t t1 -d DEMO_T1_3.dat -b
drop column
기능
사용자가 테이블에서 column을 제거할 경우에 사용한다. drop column 기능은 메모리 모드이면서 일반 테이블 타입인 경우에만 사용할 수 있고 column이 index key로 사용 중일 경우에는 수행할 수 없다.
이 명령은 내부적으로 데이터 export → 테이블 재생성 → 데이터 import 과정을 수행하기 때문에 application들이 접속된 상태에서 동작할 경우 오류가 발생할 수 있으므로 application을 모두 종료한 후에 수행해야 한다.
구문
<drop column> ::= ALTER TABLE table_name DROP COLUMN column_name
;table_name: Column을 삭제할 table의 이름
column_name: 삭제할 column의 이름
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 > 0 --------------------------------------------------------------------------------- C1 : 1 C2 : a C3 : 1 C4 : a --------------------------------------------------------------------------------- C1 : 2 C2 : b C3 : 2 C4 : b --------------------------------------------------------------------------------- C1 : 3 C2 : c C3 : 3 C4 : c --------------------------------------------------------------------------------- 3 row selected dbmMetaManager(DEMO)> alter table t1 drop column c2 success dbmMetaManager(DEMO)> select * from t1 where c1 > 0 --------------------------------------------------------------------------------- C1 : 1 C3 : 1 C4 : a --------------------------------------------------------------------------------- C1 : 2 C3 : 2 C4 : b --------------------------------------------------------------------------------- C1 : 3 C3 : 3 C4 : c --------------------------------------------------------------------------------- 3 row selected
데이터 건수에 따라 수행 완료까지 소요되는 시간이 길어질 수 있다.
drop column 구문이 동작하는 도중에 오류로 인해 복구가 필요한 경우에는 별도의 dbmMetaManager에 새롭게 접속하면 drop column 작업에 대한 복구를 수행하여 원래의 상태로 복구할 수 있다.
그러나 알 수 없는 원인으로 자동 복구되지 않을 경우에는 drop column 수행 시점에 백업된 데이터를 이용해 수동으로 복구할 수 있다.
백업 데이터는 $DBM_HOME/trc 경로에 table 이름과 SCN 정보를 기반으로 데이터 파일로 생성된다. 이 파일은 dbmImp가 binary 모드로 인식할 수 있는 파일이므로 새롭게 테이블을 생성한 후에 다음과 같은 명령으로 데이터를 복구할 수 있다.
dbmImp -i demo -t t1 -d DEMO_T1_3.dat -b
rename column
기능
사용자가 테이블에서 column의 이름만 변경할 경우에 사용한다.
이 명령을 사용하면 dictionary의 정보를 교체하는 과정이 발생하기 때문에 application들을 차단한 후에 수행해야 한다.
구문
<rename column> ::= ALTER TABLE table_name RENAME COLUMN org_column_name TO new_column_name
;table_name: Column 이름을 변경할 대상 table의 이름
org_column_name: 기존 column 이름
new_column_name: 새로 사용할 column 이름
사용 예
dbmMetaManager(DEMO)> desc t1 ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(12) ------------------------------------------------------------------------------------- C1 int 4 0 C2 int 4 4 C3 int 4 8 ------------------------------------------------------------------------------------- success dbmMetaManager(DEMO)> alter table t1 rename column c2 to x359 success dbmMetaManager(DEMO)> desc t1 ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(12) ------------------------------------------------------------------------------------- C1 int 4 0 X359 int 4 4 C3 int 4 8 ------------------------------------------------------------------------------------- success
create replication
기능
Replication 대상 테이블을 등록한다.
구문
<create replication> ::= CREATE REPLICATION TABLE [TableList]
;
<TableList] ::= TableName [, tableName]사용 예
dbmMetaManager(DEMO)> create replication table t1, t2; success
alter replication
기능
Replication 대상 테이블을 추가/삭제한다.
구문
<alter replication> ::= ALTER REPLICATION [ADD|DROP] TABLE [TableList]
;
<ADD> : 테이블을 이중화 대상으로 추가
<DROP> : 테이블을 이중화 대상에서 제거
<TableList] ::= TableName [, tableName]사용 예
dbmMetaManager(DEMO)> alter replication add table t1, t2; success
위 명령은 dbmPrepareTable을 수행하는 시점에만 유효하기 때문에 현재 동작 중인 이중화에는 영향을 주지 않는다.
alter system replication sync
기능
Master 측에서 다음 목적을 위해 사용한다. - 미전송 로그를 slave로 전송한다. - 특정 대상 테이블을 동기화 하기 위해 모두 scan하여 전송한다.
Slave 측에서 다음 목적을 위해 사용한다. - 미전송 로그를 공유 디스크에 설정한 경우 slave에 mount하여 동기화를 수행한다.
구문
<alter system replication> ::= ALTER SYSTEM REPLICATION SYNC
[LOCAL | ALL | TableList]
;
<LOCAL> : Slave 측에서 미전송 로그를 직접 읽어 반영 가능한 경우
<ALL> : Master 측에서 모든 이중화 대상 테이블의 데이터를 slave로 전송하고자 할 경우
<TableList] ::= TableName [, tableName]사용 예
dbmMetaManager(DEMO)> alter system replication sync; success
drop replication
기능
현재 설정된 이중화 대상 테이블을 목록에서 제거한다.
구문
<drop replication> ::= DROP RPELICATION
;사용 예
dbmMetaManager(DEMO)> drop replication; success
set instance
기능
사용자가 생성한 instance와 dictionary instance로 전환한다.
구문
<set instance> ::= SET INSTANCE instance_name
;instance_name: 전환할 instance의 이름
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(unknown)> set instance dict; success dbmMetaManager(DICT)> set instance demo; success dbmMetaManager(DEMO)>
set instance 구문은 dbmMetaManager에서만 제공되며 소문자 형태로만 동작한다.
alter sequence [currval]
기능
사용자가 생성한 sequence의 current value를 지정된 값으로 변경한다.
구문
<alter sequence> ::= ALTER SEQUENCE sequence_name SET CURRVAL = value
;sequence_name: 대상 sequence의 이름
value: 사용자가 변경할 current value
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select seq1.nextval from dual; --------------------------------------------------------------------------------- NEXTVAL : 3 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> alter sequence seq1 set currval = 1000; success dbmMetaManager(DEMO)> select seq1.currval from dual; --------------------------------------------------------------------------------- CURRVAL : 1000 --------------------------------------------------------------------------------- 1 row selected
alter system reset checkpoint
기능
현재 체크포인트를 특정 시점부터 시작하도록 로그 파일 번호를 설정한다.
Archive log를 이용한 복구를 처음부터 시작해야 할 경우에 대비하여 특정 로그 파일 번호부터 재수행하도록 설정한다.
구문
<reset perf> ::= ALTER SYSTEM RESET checkpoint <instanceName> <logfile_number>
;
<instanceName> :: 1 대상 instance 이름 입력
<logfile_number> :: 2 특정 로그파일 번호사용 예
dbmMetaManager(DEMO)> alter system reset checkpoint demo -1; success
alter system reset perf
기능
모든 통계 누적 정보 (v$sys_stat, v$sess_stat)를 초기화한다.
구문
<reset perf> ::= ALTER SYSTEM RESET PERF
;사용 예
dbmMetaManager(DEMO)> alter system reset perf success
통계 정보는 계속 누적되기 때문에 매우 오랜 기간동안 운영하여 표현 범위를 벗어날 경우나 모니터링이 필요한 경우 reset 명령을 사용하여 초기화 할 수 있다.
DML
데이터 추가/ 갱신/ 삭제/ 조회 및 queue table에 대한 enqueue/ dequeue 관련 구문을 설명한다.
insert
기능
사용자가 지정한 테이블에 한 건의 데이터를 추가한다. 구문에 expired 될 시간 (초)을 지정할 경우 해당 데이터는 삽입 시점부터 지정한 시간이 지나면 자동으로 삭제된다. 삽입된 후에 접근이 발생하지 않으면 데이터는 계속 유지되지만 언젠가 full scan 등과 같은 접근이 발생하면 자동으로 제거된다.
Expired time이 설정된 레코드는 별도의 데몬 프로세스에 의해 관리되지 않기 때문에 1초 정도의 오차 범위 내에서 조회될 수 있으며 이는 복구 과정에서도 1초 정도 유지된 후 제거될 수 있다는 것에 주의해야 한다.
구문
<insert> ::= INSERT INTO table_name
[ column_name [, ...] ]
VALUES
( value_expression [, ...] )
[ EXPIRED expiredTime ]
;table_name: 데이터를 저장할 대상 테이블
expiredTime: 저장 후 삭제될 시간을 초 단위로 지정 (커밋 시점이 아닌 호출 시점을 기준으로 동작)
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> desc t1; ------------------------------------------------------------------------------------- Instance=(DEMO) Table=(T1) Type=(TABLE) RowSize=(48) ------------------------------------------------------------------------------------- C1 int 4 0 C2 double 8 8 C3 char 20 16 C4 date 8 40 ------------------------------------------------------------------------------------- IDX_T1 unique (C1) ------------------------------------------------------------------------------------- success dbmMetaManager(DEMO)> insert into t1 (c1, c2, c3, c4) values (1, 1, 1, sysdate); success dbmMetaManager(DEMO)> insert into t1 (c1, c2) values (2, 2) expired 5; success dbmMetaManager(DEMO)> insert into t1 values (3, 3, 3, sysdate); success dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 1.000000 C3 : 1 C4 : 2019/01/02 16:44:17.227558 --------------------------------------------------------------------------------- C1 : 2 C2 : 2.000000 C3 : C4 : 1970/01/01 09:00:00.000000 --------------------------------------------------------------------------------- C1 : 3 C2 : 3.000000 C3 : 3 C4 : 2019/01/02 16:44:37.283193 --------------------------------------------------------------------------------- 3 row selected
Insert 작업이 수행된 레코드는 commit 전까지는 다른 세션에서 조회되지 않는다. 또한 unique index에 동일한 데이터를 추가하는 다른 세션은 대기한다.
Direct table에 index를 생성하지 않으면 테이블 저장 위치를 판단할 수 없기 때문에 반드시 index를 미리 생성해야 한다.
metaManager에서 INSERT를 수행할 때 기술되지 않은 column의 값은 모두 0x00으로 저장된다.
update
기능
사용자가 지정한 테이블에서 한 건 이상의 데이터를 갱신한다.
구문
<update> ::= UPDATE table_name
SET column_name = value_expression [, ...]
[ WHERE cond_expression ]
;table_name: 데이터를 갱신할 대상 테이블
column_name: 테이블 내의 column 이름
value_expression: 갱신할 value
cond_expression: 갱신할 조건절
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 1.000000 C3 : 1 C4 : 2019/01/02 16:44:17.227558 --------------------------------------------------------------------------------- C1 : 2 C2 : 2.000000 C3 : C4 : 1970/01/01 09:00:00.000000 --------------------------------------------------------------------------------- C1 : 3 C2 : 3.000000 C3 : 3 C4 : 2019/01/02 16:44:37.283193 --------------------------------------------------------------------------------- 3 row selected dbmMetaManager(DEMO)> update t1 set c2 = 100 where c1 >= 1; 3 row updated. dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 100.000000 C3 : 1 C4 : 2019/01/02 16:44:17.227558 --------------------------------------------------------------------------------- C1 : 2 C2 : 100.000000 C3 : C4 : 1970/01/01 09:00:00.000000 --------------------------------------------------------------------------------- C1 : 3 C2 : 100.000000 C3 : 3 C4 : 2019/01/02 16:44:37.283193 --------------------------------------------------------------------------------- 3 row selected
update로 갱신된 레코드는 lock으로 다른 세션의 접근을 막는다. select는 update 이전 데이터를 조회하도록 동작한다. 따라서 갱신되고 있는 중에도 갱신 전 형태를 조회할 수 있다.
delete
기능
사용자가 지정한 테이블에서 한 건 이상의 데이터를 삭제한다.
구문
<delete> ::= DELETE FROM table_name
[ WHERE cond_expression ]
;table_name: 데이터를 갱신할 대상 테이블
cond_expression: 갱신할 조건절
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 1.000000 C3 : 1 C4 : 2019/01/02 16:44:17.227558 --------------------------------------------------------------------------------- C1 : 2 C2 : 2.000000 C3 : C4 : 1970/01/01 09:00:00.000000 --------------------------------------------------------------------------------- C1 : 3 C2 : 3.000000 C3 : 3 C4 : 2019/01/02 16:44:37.283193 --------------------------------------------------------------------------------- 3 row selected dbmMetaManager(DEMO)> delete from t1 where c1 >= 1; 3 row deleted. dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- 0 row selected
delete로 삭제할 레코드는 lock으로 다른 세션의 접근을 막는다. select는 update 이전 데이터를 조회하도록 동작한다. 따라서 갱신되고 있는 중에도 갱신 전 형태를 조회할 수 있다.
select
기능
사용자가 지정한 테이블에서 한 건 이상의 데이터를 조회한다.
구문
<select> ::= SELECT target_list FROM table_name [alias, table_name alias]
[ WHERE cond_expression ]
[ FOR UPDATE ]
[ LIMIT [ start_offset, ] fetch_limit_count ]
;• target_list ::= *
| column_name [, ... ]
• table_name: 데이터를 조회할 대상 테이블 또는 join 할 driving-table, driven-table
• cond_expression: 조회할 조건절
• FOR UPDATE: Select 할 때 lock을 걸어 변경되는 것을 방지해야 할 경우에 사용
• start_offset: 결과 집합에서 출력을 시작할 레코드의 순서를 지정
• fetch_limit_count: 결과 집합에서 출력할 레코드의 개수를 지정사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 1 C3 : abc --------------------------------------------------------------------------------- C1 : 2 C2 : 2 C3 : def --------------------------------------------------------------------------------- 2 row selected dbmMetaManager(DEMO)> select c1, c3 from t1 where c1 = 2; --------------------------------------------------------------------------------- C1 : 2 C3 : def --------------------------------------------------------------------------------- 1 row selected
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int) success dbmMetaManager(DEMO)> create unique index idx_t1 on t1 (c1) success dbmMetaManager(DEMO)> insert into t1 values (1, 1) success dbmMetaManager(DEMO)> insert into t1 values (2, 2) success dbmMetaManager(DEMO)> insert into t1 values (3, 3) success dbmMetaManager(DEMO)> insert into t1 values (4, 4) success dbmMetaManager(DEMO)> insert into t1 values (5, 5) success dbmMetaManager(DEMO)> commit success dbmMetaManager(DEMO)> create table t2 (c1 int, c2 int) success dbmMetaManager(DEMO)> create unique index idx_t2 on t2 (c1) success dbmMetaManager(DEMO)> insert into t2 values (1, 11) success dbmMetaManager(DEMO)> insert into t2 values (2, 22) success dbmMetaManager(DEMO)> insert into t2 values (3, 33) success dbmMetaManager(DEMO)> insert into t2 values (4, 44) success dbmMetaManager(DEMO)> insert into t2 values (5, 55) success dbmMetaManager(DEMO)> commit success dbmMetaManager(DEMO)> select * from t1 a, t2 b where a.c1 = b.c1 Access Count = 5 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 C1 : 1 C2 : 11 --------------------------------------------------------------------------------- C1 : 2 C2 : 2 C1 : 2 C2 : 22 --------------------------------------------------------------------------------- C1 : 3 C2 : 3 C1 : 3 C2 : 33 --------------------------------------------------------------------------------- C1 : 4 C2 : 4 C1 : 4 C2 : 44 --------------------------------------------------------------------------------- C1 : 5 C2 : 5 C1 : 5 C2 : 55 --------------------------------------------------------------------------------- 5 row selected dbmMetaManager(DEMO)> select * from t1 a, t2 b where a.c1 = 1 and a.c1 = b.c1 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 C1 : 1 C2 : 11 --------------------------------------------------------------------------------- 1 row selected ---------------------------------- -- LIMIT Sample ---------------------------------- dbmMetaManager(DEMO)> select * from t1 where c1 > 9999 and c1 < 100000 limit 30, 3; --------------------------------------------------------------------------------- C1 : 10029 C2 : --------------------------------------------------------------------------------- C1 : 10030 C2 : --------------------------------------------------------------------------------- C1 : 10031 C2 : --------------------------------------------------------------------------------- 3 row selected
GOLDILOCKS LITE는 다른 DBMS와 달리 첫 번째로 명시된 테이블을 driving-table로 자동 선정하여 join 한다. 세 개 이상의 테이블은 join 할 수 없다.
Direct 테이블은 지정된 key를 위치 판단용로 사용하기 때문에 일반 테이블과 달리 GT/ LT 연산을 정확하게 수행할 수 없다. 즉, 일종의 ordering 되지 않은 array와 같은 개념이므로 조회할 때 정렬되지 않거나 GT/ LT의 연산 결과가 기대한 것과 다를 수 있다. 따라서 direct 테이블은 key를 기준으로 한 equal 연산으로 빨리 처리해야 할 경우에 사용할 것을 권장한다.
LIMIT 절은 실제 데이터를 가져오기 전, 최종 결과 집합을 만든 후에 적용되기 때문에 실행 속도를 줄일 수 없다.
GROUP BY 및 ORDER BY는 다음과 같이 지원된다.
<select> ::= SELECT target_list FROM table_name [alias, table_name alias]
[ WHERE cond_expression ]
[ GROUP BY target_id [, target_id] ]
[ ORDER BY target_id [, target_id] ]
;• target_list ::= *
| column_name [, ... ]
• table_name: 데이터를 조회할 대상 테이블 또는 join 할 driving-table, driven-table
• cond_expression: 조회할 조건절
• target_id: target_list에 기술한 column의 순서를 의미 (base=1)group by에 의해 기술될 수 있는 target은 column identifier로 제한된다. 또한, aggregation 함수는 min, max, sum, avg, count로 제한된다. 만일, 일반적인 column identifier가 아닌 다른 함수가 기술되면 지원되지 않는다. 다음 예제를 참고한다.
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int, c3 int) success dbmMetaManager(DEMO)> insert into t1 values (10, 5, 4) success dbmMetaManager(DEMO)> insert into t1 values (10, 4, 4) success dbmMetaManager(DEMO)> insert into t1 values (1, 1, 1) success dbmMetaManager(DEMO)> insert into t1 values (1, 2, 1) success dbmMetaManager(DEMO)> insert into t1 values (2, 3, 1) success dbmMetaManager(DEMO)> insert into t1 values (2, 8, 1) success dbmMetaManager(DEMO)> insert into t1 values (3, 4, 1) success dbmMetaManager(DEMO)> insert into t1 values (3, 5, 1) success dbmMetaManager(DEMO)> insert into t1 values (4, 6, 1) success dbmMetaManager(DEMO)> insert into t1 values (4, 8, 1) success dbmMetaManager(DEMO)> insert into t1 values (4, 9, 1) success dbmMetaManager(DEMO)> insert into t1 values (4, 10, 1) success dbmMetaManager(DEMO)> commit success dbmMetaManager(DEMO)> select c1, sum(c2) from t1 group by 1 --------------------------------------------------------------------------------- C1 : 1 SUM : 3 --------------------------------------------------------------------------------- C1 : 2 SUM : 11 --------------------------------------------------------------------------------- C1 : 3 SUM : 9 --------------------------------------------------------------------------------- C1 : 4 SUM : 33 --------------------------------------------------------------------------------- C1 : 10 SUM : 9 --------------------------------------------------------------------------------- 5 row selected
select for update
기능
사용자가 지정한 테이블에서 한 건 이상의 데이터를 조회하고 해당 레코드에 lock을 수행한다.
구문
<select_for_update> ::= SELECT target_list FROM table_name
[ WHERE cond_expression ]
FOR UPDATE
;• target_list ::= *
| column_name [, ... ]
• table_name : 데이터를 조회할 대상 테이블
• cond_expression : 조회할 조건절사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select * from t1 for update; --------------------------------------------------------------------------------- C1 : 1 C2 : 1 C3 : abc --------------------------------------------------------------------------------- C1 : 2 C2 : 2 C3 : def --------------------------------------------------------------------------------- 2 row selected dbmMetaManager(DEMO)> select c1, c3 from t1 where c1 = 2 for update; --------------------------------------------------------------------------------- C1 : 2 C3 : def --------------------------------------------------------------------------------- 1 row selected
select_for_update에 의해 lock이 걸린 레코드에 접근하는 다른 세션에서는 select가 허용되지만 lock을 걸어야 하는 DML은 commit/ rollback 이전까지 대기한다.
JOIN 구문에서는 FOR UPDATE 기능을 사용할 수 없다.
enqueue
기능
사용자가 지정한 테이블에 한 건의 데이터를 enqueue 한다.
구문
<enqueue> ::= ENQUEUE INTO table_name
[ target_list ]
VALUES
( value_expression [, ...] )
;target_list ::= ( column_name [, ...] )
table_name: 데이터를 삽입할 대상 테이블이다.
value_expression: 삽입할 value 이다.
사용 예
***********************************************************
* Copyright © 2010 SUNJESOFT Inc. All rights reserved.
***********************************************************
dbmMetaManager(DEMO)> create queue que1 size 100;
success
dbmMetaManager(DEMO)> enqueue into que1 (msg_type, priority, msg_size, message)
2 values (1, 90, 10, 'msg1234567');
success
dbmMetaManager(DEMO)> commit;
success
dbmMetaManager(DEMO)> select * from que1;
---------------------------------------------------------------------------------
MSG_TYPE : 1
PRIORITY : 90
ID : 1
MSG_SIZE : 10
IN_TIME : 2019/01/02 17:37:14.814588
MESSAGE : msg1234567
---------------------------------------------------------------------------------
1 row selectedTarget_list에 기술할 수 있는 항목은 msg_type, priority, msg_size, message 이다. msg_size, message는 필수 항목이며 그 외의 항목들은 모두 0으로 저장된다.
dbmMetaManager(DEMO)> enqueue into que1 (msg_size, message) values (10, 'msg7654321'); success dbmMetaManager(DEMO)> commit; success dbmMetaManager(DEMO)> select * from que1; --------------------------------------------------------------------------------- MSG_TYPE : 0 PRIORITY : 0 ID : 2 MSG_SIZE : 10 IN_TIME : 2019/01/02 17:40:41.569927 MESSAGE : msg7654321 --------------------------------------------------------------------------------- 1 row selected
insert 구문을 사용하여 수행할 경우 다음과 같은 오류가 발생한다.
dbmMetaManager(DEMO)> insert into que1 (msg_type, priority, msg_size, message) values (1, 90, 10, 'msg1234567'); Command] <insert into que1 (msg_type, priority, msg_size, message) values (1, 90, 10, 'msg1234567')> ERR-102007] fail to execute a statement ERR-102047] a operation can not be executed on target-table (check table type)
dequeue
기능
사용자가 지정한 테이블에서 한 건의 데이터를 dequeue 한다.
구문
<dequeue> ::= DEQUEUE FROM table_name
[ WHERE cond_expression ]
;table_name: 대상 테이블이다.
cond_expression: Dequeue 할 조건절이다.
사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> select * from que1; --------------------------------------------------------------------------------- MSG_TYPE : 1 PRIORITY : 90 ID : 1 MSG_SIZE : 10 IN_TIME : 2019/01/02 17:37:14.814588 MESSAGE : msg1234567 --------------------------------------------------------------------------------- MSG_TYPE : 0 PRIORITY : 0 ID : 2 MSG_SIZE : 10 IN_TIME : 2019/01/02 17:40:41.569927 MESSAGE : msg7654321 --------------------------------------------------------------------------------- 2 row selected dbmMetaManager(DEMO)> dequeue from que1 where msg_type = 1; MSG_TYPE : 1 PRIORITY : 90 ID : 1 MSG_SIZE : 10 IN_TIME : 2019/01/02 17:37:14.814588 MESSAGE : msg1234567
별도의 조건절이 없을 경우, msg_type이 0이면서 priority 값이 낮은 레코드들 중에 먼저 enqueue commit 된 레코드부터 dequeue 된다.
DCL
DCL은 사용자가 수행한 각 트랜잭션을 영구적으로 commit/ rollback 하기 위해 제공되는 명령문이다.
commit
기능
사용자가 발생시킨 모든 트랜잭션을 영구적으로 commit 한다.
구문
<commit> ::= COMMIT
;사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> commit; success
rollback
기능
사용자가 발생시킨 모든 트랜잭션을 원래 상태로 rollback 한다.
구문
<rollback> ::= ROLLBACK
;사용 예
*********************************************************** * Copyright © 2010 SUNJESOFT Inc. All rights reserved. *********************************************************** dbmMetaManager(DEMO)> rollback; success
Built-in Function
사용상 편의를 위해 SQL 문 유형을 수행할 때 다음과 같은 built-in function을 제공한다.
내장 함수 중에 숫자형 관련 함수들을 bind하는 시점에 타입을 지정하면 해당 타입으로 전환되긴 하지만 내부적으로 반환되는 값은 모두 8 byte double을 채택하기 때문에 사용자도 type 변환 비용이 발생하지 않도록 double 타입으로 바인딩하는 것을 권장한다.
반환되는 문자열의 크기는 최대 32 K 이다.
GOLDILOCKS LITE에서 제공하는 모든 숫자형 함수들은 overflow/ underflow와 관련된 에러를 체크하지 않는다.
Category | Function name | Return value | Desc |
|---|---|---|---|
날짜/ 시간 | sysdate | long (8 bytes) | 내부 저장 용도의 8 byte long long 형태의 값으로 저장하고 출력한다. |
extract | int (4 bytes) | 날짜형식의 값에서 지정된 항목의 값을 숫자형으로 반환한다. | |
datetime_str | char (64 bytes 이내) | Date column을 문자열로 출력한다. | |
to_date | date (8 bytes) | 사용자 입력 문자열을 date type 값으로 변환한다. | |
datediff | long (8 bytes) | 입력된 날짜 타입의 두 개인자 사이의 간격을 초단위로 출력한다. | |
Dump | dump | char (최대 1Mbyte) | ascii를 출력한다. byte당 2~4 byte로 출력된다. |
hex | char (최대 1Mbyte) | hex를 출력한다. byte당 2 byte로 출력된다. | |
문자형 | concat | char (최대 1Mbyte) | 두 번째 인자의 문자열을 첫번째 인자에 붙여서 출력한다. |
instr | int (4 bytes) | 소스문자열 내에 지정된 문자열이 존재할 경우 시작 위치를 1로 하여 offset을 출력한다. | |
replace | char (최대 1Mbyte) | 검색어를 찾아 지정된 문자열로 치환한다. | |
substr | char (최대 1Mbyte) | 문자열에서 지정된 위치부터 입력된 크기만큼 잘라낸다. | |
length | int (4 bytes) | NULL 지점까지의 길이를 반환하며 NULL이 없을 경우 오류가 발생할 수 있다. | |
ltrim | char (최대 1 Mbyte) | 문자열의 왼쪽 공백 또는, 지정된 문자를 제거한다. | |
rtrim | char (최대 1 Mbyte) | 문자열의 오른쪽 공백, 또는 지정된 문자를 제거한다. | |
lpad | char (최대 1 Mbyte) | 문자열의 왼쪽에 지정한 문자열을 추가한다. | |
rpad | char (최대 1 Mbyte) | 문자열의 오른쪽에 지정한 문자열을 추가한다. | |
upper | char (최대 1 Mbyte) | 값을 대문자로 변환한다. | |
lower | char (최대 1 Mbyte) | 값을 소문자로 변환한다. | |
숫자형 | abs | double (8 bytes) | 절대값으로 변환한다. |
power | double (8 bytes) | 입력된 수의 제곱을 출력한다. | |
sqrt | double (8 bytes) | 입력된 수의 제곱근을 출력한다. | |
log | double (8 bytes) | base를 기준으로 하는 자연로그 결과를 출력한다. | |
exp | double (8 bytes) | e의 제곱을 출력한다. | |
mod | double (8 bytes) | 나머지 연산을 한다. | |
ceil | double (8 bytes) | 소수점을 올림한다. | |
floor | double (8 bytes) | 소수점을 내림한다. | |
round | double (8 bytes) | 반올림 한다. | |
trunc | double (8 bytes) | 절사 연산을 한다. | |
random | Int (4 bytes) | 주어진 입력값 사이의 random 정수를 출력한다. | |
Sequence | currval | long long (8 bytes) | - |
nextval | long long (8 bytes) | - | |
단방향 hash 암호화 | digest | char (64 bytes) | 알고리즘에 따라 반환되는 길이가 다르다. |
Aggregation | min | double (8 bytes) | group by를 지원하지 않는다. |
max | double (8 bytes) | ||
avg | double (8 bytes) | ||
sum | double (8 bytes) | ||
JSON OBJECT | JSON_STRING | char | 일반 테이블 결과를 JSON 형태로 반환한다. |
JSON_KEY | char | create index를 수행할 때 json 내부의 path를 key로 설정한다. | |
JSON_VALUE | char | json format string에서 특정 필드를 찾아 반환한다. | |
JSON_QUERY | char | json format string에서 특정 필드를 찾아 json format으로 반환한다. | |
기타 | decode | char (최대 1 Mbyte) | 결과와 일치하는 경우 사용자가 지정한 값을 반환한다. |
nvl | char (최대 1 Mbyte) | 지정된 값이 NULL일 경우 사용자가 지정한 값을 반환한다. | |
USER_TYPE | char (최대 1 Mbyte) | Column을 user_type으로 캐스팅하여 출력한다. |
sysdate
현재 시스템 시간을 구하여 date type으로 반환한다. (단, dbmMetaManager에서 조회할 때는 long long type이 아닌 string 형태로 반환한다. )
사용 예
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 date); success dbmMetaManager(DEMO)> insert into t1 values (1, sysdate); success dbmMetaManager(DEMO)> commit; success dbmMetaManager(DEMO)> select * from t1; --------------------------------------------------------------------------------- C1 : 1 C2 : 2019/04/04 13:08:47.416266 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select sysdate from dual; --------------------------------------------------------------------------------- SYSDATE : 2021/02/01 15:32:50.110855 --------------------------------------------------------------------------------- 1 row selected
다른 DBMS에서와는 달리 sysdate가 DML에서 날짜를 처리하기 위한 pseudo code처럼 사용된다. 따라서 sysdate가 binary 형태의 데이터로 출력된다. 현재 시각을 확인하려면 CURRENT를 사용해야 한다.
extract
주어진 날짜시간 타입의 데이터에서 입력된 항목의 필드를 숫자형으로 추출한다. 추출 가능한 항목은 다음과 같다.
YEAR
MONTH
DAY
HOUR
MINUTE
SECOND
사용 예
dbmMetaManager(DEMO)> select extract( 'year' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 2021
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select extract( 'month' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 12
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select extract( 'day' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 31
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select extract( 'hour' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 11
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select extract( 'minute' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 58
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select extract( 'second' from to_date('20211231115859', 'yyyymmddhhmiss') ) from dual
---------------------------------------------------------------------------------
EXTRACT : 59
---------------------------------------------------------------------------------
1 row selecteddatetime_str
Date type의 column을 string으로 출력한다. 포맷은 YYYY-MM-DD H24:MI:SS.SSSSSS로 고정되어 있다. 인자로는 date type을 사용할 수 있다.
사용 예
dbmMetaManager(DEMO)> select datetime_str(sysdate) from dual; --------------------------------------------------------------------------------- DATETIME_STR : 2020-08-24 14:23:33.452934 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)>
to_date( '문자열', 'Format')
사용자 입력 문자열을 일정한 형식의 date 타입 값으로 변환한다. Default 형식은 "YYYY/MM/DD H24:MI:SS.S6" 로 고정되어 있다.
Format 지정은 다음 표를 참조한다.
Format | 설명 |
|---|---|
YYYY | 4 자리 연도이다. |
MM | 월의 단위로서 (01~12) 범위이다. |
DD | 일의 단위로서 (01~31) 범위이다. |
HH | 시간의 단위로서 (00~23) 범위이다. |
MI | 분의 단위로서 (00~59) 범위이다. |
SS | 초의 단위로서 (00~59) 범위이다. |
S3 | Millisecond까지 사용하는 경우로서 3 자리이다. |
S6 | Microsecond까지 사용하는 경우로서 6 자리이다. |
사용 예
dbmMetaManager(DEMO)> select to_date( '2020/12/31 15:38:41.123456', 'yyyy/mm/dd hh:mi:ss.s6') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 15:38:41.123456 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12/31 15:38:41.123', 'yyyy/mm/dd hh:mi:ss.s3') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 15:38:41.123000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12/31 15:38:41', 'yyyy/mm/dd hh:mi:ss') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 15:38:41.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12/31 15:38', 'yyyy/mm/dd hh:mi') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 15:38:00.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12/31 15', 'yyyy/mm/dd hh') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 15:00:00.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12/31', 'yyyy/mm/dd') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/31 00:00:00.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020/12', 'yyyy/mm') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/01 00:00:00.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '2020', 'yyyy') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/01 00:00:00.000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select to_date( '11:31', 'hh:mi') from dual --------------------------------------------------------------------------------- TO_DATE : 2020/12/01 11:31:00.000000 --------------------------------------------------------------------------------- 1 row selected
Format이 지정되지 않는 경우에는 사용자의 문자열을 기본 포맷 형태로 일치시켜야 하는데 이 때 연/월/일을 포함해야 하며 그렇지 않은 경우에는 오류가 발생한다.
dbmMetaManager(DEMO)> select to_date('2020/12/31 12:40') from dual
---------------------------------------------------------------------------------
TO_DATE : 2020/12/31 12:40:00.000000
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select to_date('12:40') from dual
Command] <select to_date('12:40') from dual>
ERR-70033] fail to execute a statement
ERR-70047] invalid expression type
ERR-70001] fail to validate some parameters at internal processing다음과 같이 DML에 함수를 포함시켜서 사용할 수 있다.
dbmMetaManager(DEMO)> insert into t1 values (1, sysdate)
success
dbmMetaManager(DEMO)> insert into t1 values (1, to_date('2002/05/26 11:31:45.123456') )
success
dbmMetaManager(DEMO)> commit
success
dbmMetaManager(DEMO)> select * from t1
---------------------------------------------------------------------------------
C1 : 1
C2 : 2020/12/28 16:26:18.548964
---------------------------------------------------------------------------------
C1 : 1
C2 : 2002/05/26 11:31:45.123456
---------------------------------------------------------------------------------datediff( From, to )
입력된 날짜 타입의 인자 두 개 (from ~ to) 사이의 간격을 초단위로 환산하여 반환한다.
사용 예
dbmMetaManager(DEMO)> select datediff( to_date('20201231', 'yyyymmdd'), to_date('20200101', 'yyyymmdd') ) from dual
---------------------------------------------------------------------------------
DATEDIFF : 31536000
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select datediff( to_date('20201231', 'yyyymmdd'), to_date('20200101', 'yyyymmdd') ) / (60 * 60 * 24) from dual
---------------------------------------------------------------------------------
DIVIDE : 365.000000000
---------------------------------------------------------------------------------
1 row selecteddump( value, [base] )
지정된 문자열 value에 대해 byte 단위로 ascii 값으로 변환한 text를 반환한다. Base를 별도로 지정하지 않을 경우 default로 10 진수 ascii로 동작하며 16 진수를 지원한다.
사용 예
dbmMetaManager(DEMO)> select c1 from t1; --------------------------------------------------------------------------------- C1 : a --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select dump(c1, 16) from t1; --------------------------------------------------------------------------------- DUMP : len=1: 61 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select dump(c1, 10) from t1; --------------------------------------------------------------------------------- DUMP : len=1: 97 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select dump(c1) from t1; --------------------------------------------------------------------------------- DUMP : len=1: 97 --------------------------------------------------------------------------------- 1 row selected
Hex (Value)
인자로 주어진 문자열 value를 hex code로 출력한다.
사용 예
dbmMetaManager(DEMO)> select hex( 'abc' ) from dual --------------------------------------------------------------------------------- HEX : 616263 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)
concat( target, append )
target 문자열 뒤에 append 문자열을 추가하는 연산을 수행한다. (strcat 연산)
사용 예
dbmMetaManager(DEMO)> select concat( 'abc', 'def') from dual; --------------------------------------------------------------------------------- CONCAT : abcdef --------------------------------------------------------------------------------- 1 row selected
instr( source, keyword, [start, #appearance] )
Source 문자열 내에서 keyword를 찾아 위치를 반환한다. start가 생략되면 처음부터 시작하고 음수인 경우 역순으로 검색한다. 만일 입력값이 0이면 출력값은 keyword에 상관없이 0으로 반환된다. #appearance는 keyword가 source 내에 출현한 횟수가 일치하는 지점을 탐색한다.
사용 예
dbmMetaManager(DEMO)> select instr( 'abcdef abcdef', 'def' ) from dual
---------------------------------------------------------------------------------
INSTR : 11
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select instr( 'abcdef abcdef', 'def', 1, 2 ) from dual
---------------------------------------------------------------------------------
INSTR : 11
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select instr('abcd abcd abcd', 'bc', -5, 2) from dual
---------------------------------------------------------------------------------
INSTR : 2
---------------------------------------------------------------------------------
1 row selectedreplace( source, keyword, replace )
Source 문자열 내에 keyword를 찾아 replace 문자열을 변경하는 연산을 수행한다.
사용 예
dbmMetaManager(DEMO)> select replace( 'abc, abc ing', 'abc', 'xxxxx' ) from dual --------------------------------------------------------------------------------- REPLACE : xxxxx, xxxxx ing --------------------------------------------------------------------------------- 1 row selected
substrt( source, start_position, count )
Source 문자열의 start_position부터 count 만큼 문자열을 잘라 반환한다.
Count가 생략될 경우 start_position부터 남은 문자열을 모두 반환한다.
Start_position이 source 문자열 길이를 초과할 경우, NULL을 반환한다.
사용 예
dbmMetaManager(DEMO)> select substr( 'abcdefghi', 4) from t1 --------------------------------------------------------------------------------- SUBSTR : defghi --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select substr( 'abcdefghi', 9, 5) from t1 --------------------------------------------------------------------------------- SUBSTR : i --------------------------------------------------------------------------------- 1 row selected
length( Source )
Source 문자열 길이를 반환한다. 중간에 NULL이 있다면 그 위치까지의 길이만 반환한다.
사용 예
dbmMetaManager(DEMO)> select length( ltrim( rpad(' str', 20, 'x') ) ) from dual
---------------------------------------------------------------------------------
LENGTH : 18
---------------------------------------------------------------------------------
1 row selectedltrim / rtrim( source )
Source 문자열의 왼쪽 또는 오른쪽에 존재하는 공백 문자를 제거하여 반환한다.
사용 예
dbmMetaManager(DEMO)> select ltrim( ' xyz' ) from dual --------------------------------------------------------------------------------- LTRIM : xyz --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select rtrim( 'xyz ' ) from dual --------------------------------------------------------------------------------- RTRIM : xyz --------------------------------------------------------------------------------- 1 row selected
lpad / rpad( source, size, padding_string)
Source 문자열의 왼쪽 또는 오른쪽에 사용자가 입력한 padding_string을 size 이내로 추가하여 반환한다.
사용 예
dbmMetaManager(DEMO)> select lpad('aa', 10, 'x') from dual
---------------------------------------------------------------------------------
LPAD : xxxxxxxxaa
---------------------------------------------------------------------------------
dbmMetaManager(DEMO)> select rpad('aa', 10, 'x') from dual
---------------------------------------------------------------------------------
RPAD : aaxxxxxxxx
---------------------------------------------------------------------------------
1 row selectedabs( value )
입력 항목의 절대값을 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select abs(-123) from dual; --------------------------------------------------------------------------------- ABS : 123.000000000 --------------------------------------------------------------------------------- 1 row selected
mod( value1, value2 )
(value1 / value2) 연산으로 발생한 나머지 값을 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select mod(14, 3) from dual; --------------------------------------------------------------------------------- MOD : 2.000000000 --------------------------------------------------------------------------------- 1 row selected
ceil( value )
Value 보다 큰 가장 가까운 정수를 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select ceil( 12.345) from dual; --------------------------------------------------------------------------------- CEIL : 13.000000000 --------------------------------------------------------------------------------- 1 row selected
floor( value )
Value 보다 작은 가장 가까운 정수를 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select floor(13.678) from dual; --------------------------------------------------------------------------------- FLOOR : 13.000000000 --------------------------------------------------------------------------------- 1 row selected
round( value )
Value를 반올림하여 정수를 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select round(12.345) from dual; --------------------------------------------------------------------------------- ROUND : 12.000000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select round(12.678) from dual; --------------------------------------------------------------------------------- ROUND : 13.000000000 ---------------------------------------------------------------------------------
trunc( value, [pos] )
Value가 소수점일 경우 지정된 pos 위치에서 소수점 이하의 수를 제거한 후에 반환한다. 지정되지 않은 경우 소수점 이하를 모두 버린 후에 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select trunc(13.34567) from dual; --------------------------------------------------------------------------------- TRUNC : 13.000000000 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select trunc(13.34567, 2) from dual; --------------------------------------------------------------------------------- TRUNC : 13.340000000 ---------------------------------------------------------------------------------
random( from, to )
From, To로 지정된 범위 내의 random 정수를 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select random(1, 10) from dual --------------------------------------------------------------------------------- RANDOM : 2 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select random(100, 200) from dual --------------------------------------------------------------------------------- RANDOM : 144 --------------------------------------------------------------------------------- 1 row selected
substr( value, [start], [count] )
문자열 value에 대해 start 위치에서 count만큼 문자열을 잘라 반환한다.
start, count를 입력할 경우 음수로 지정할 수 없다.
count가 지정되지 않은 경우, start 위치부터 마지막 문자열까지 반환한다.
사용 예
dbmMetaManager(DEMO)> select substr( 'abcdefg', 3, 1) from dual; --------------------------------------------------------------------------------- SUBSTR : c --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select substr( 'abcdefg', 3) from dual; --------------------------------------------------------------------------------- SUBSTR : cdefg ---------------------------------------------------------------------------------
nextval
지정된 sequence의 다음 값을 반환한다.
사용 예
dbmMetaManager(DEMO)> select seq1.nextval from dual; --------------------------------------------------------------------------------- NEXTVAL : 2 --------------------------------------------------------------------------------- 1 row selected
currval
지정된 sequence의 현재 값을 반환한다.
사용 예
dbmMetaManager(DEMO)> select seq1.currval from dual; --------------------------------------------------------------------------------- CURRVAL : 2 --------------------------------------------------------------------------------- 1 row selected
Sequence 객체에 대해 nextval이 호출되지 않았을 때 currval을 호출하면 오류를 반환한다.
Digest (Value, SHA-type)
입력된 문자열 value와 SHA-type로 암호화 된 결과를 출력한다. Digest 처리된 결과는 binary 형태로써 화면에 정상적으로 출력되지 않을 수도 있다. 이 경우, 다음과 같이 hex 함수 등을 통해 확인할 수 있다.
사용 예
dbmMetaManager(DEMO)> select hex( digest( 'my password', 'SHA256' ) ) from dual --------------------------------------------------------------------------------- HEX : BB14292D91C6D0920A5536BB41F3A50F66351B7B9D94C804DFCE8A96CA1051F2 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> quit
Min( Column )
Select 된 결과 집합에서 min 함수 내에 정의된 column 값 중 가장 작은 값을 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 = 1; --------------------------------------------------------------------------------- C1 : 1 C2 : -1 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 --------------------------------------------------------------------------------- C1 : 1 C2 : 2 --------------------------------------------------------------------------------- C1 : 1 C2 : 3 --------------------------------------------------------------------------------- C1 : 1 C2 : 4 --------------------------------------------------------------------------------- C1 : 1 C2 : 5 --------------------------------------------------------------------------------- C1 : 1 C2 : 6 --------------------------------------------------------------------------------- C1 : 1 C2 : 7 --------------------------------------------------------------------------------- C1 : 1 C2 : 8 --------------------------------------------------------------------------------- C1 : 1 C2 : 9 --------------------------------------------------------------------------------- C1 : 1 C2 : 10 --------------------------------------------------------------------------------- 11 row selected dbmMetaManager(DEMO)> select min(c2) from t1 where c1 = 1; --------------------------------------------------------------------------------- MIN_VALUE : -1.000000000 --------------------------------------------------------------------------------- 1 row selected
Max( Column )
Select 된 결과 집합에서 max 함수 내에 정의된 column 값 중 가장 큰 값을 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 = 1; --------------------------------------------------------------------------------- C1 : 1 C2 : -1 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 --------------------------------------------------------------------------------- C1 : 1 C2 : 2 --------------------------------------------------------------------------------- C1 : 1 C2 : 3 --------------------------------------------------------------------------------- C1 : 1 C2 : 4 --------------------------------------------------------------------------------- C1 : 1 C2 : 5 --------------------------------------------------------------------------------- C1 : 1 C2 : 6 --------------------------------------------------------------------------------- C1 : 1 C2 : 7 --------------------------------------------------------------------------------- C1 : 1 C2 : 8 --------------------------------------------------------------------------------- C1 : 1 C2 : 9 --------------------------------------------------------------------------------- C1 : 1 C2 : 10 --------------------------------------------------------------------------------- 11 row selected dbmMetaManager(DEMO)> select max(c2) from t1 where c1 = 1; --------------------------------------------------------------------------------- MAX_VALUE : 10.000000000 --------------------------------------------------------------------------------- 1 row selected
Avg( Column )
Select 된 결과 집합 중에 avg 함수 내에 정의된 column 값의 평균값을 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 = 1; --------------------------------------------------------------------------------- C1 : 1 C2 : -1 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 --------------------------------------------------------------------------------- C1 : 1 C2 : 2 --------------------------------------------------------------------------------- C1 : 1 C2 : 3 --------------------------------------------------------------------------------- C1 : 1 C2 : 4 --------------------------------------------------------------------------------- C1 : 1 C2 : 5 --------------------------------------------------------------------------------- C1 : 1 C2 : 6 --------------------------------------------------------------------------------- C1 : 1 C2 : 7 --------------------------------------------------------------------------------- C1 : 1 C2 : 8 --------------------------------------------------------------------------------- C1 : 1 C2 : 9 --------------------------------------------------------------------------------- C1 : 1 C2 : 10 --------------------------------------------------------------------------------- 11 row selected dbmMetaManager(DEMO)> select avg(c2) from t1 where c1 = 1; --------------------------------------------------------------------------------- AVG : 4.909090909 --------------------------------------------------------------------------------- 1 row selected
Sum( Column )
Select 된 결과 집합에서 sum 함수 내에 정의된 column 값의 합계를 반환한다. double의 표현 범위 내에서 사용해야 한다.
사용 예
dbmMetaManager(DEMO)> select * from t1 where c1 = 1; --------------------------------------------------------------------------------- C1 : 1 C2 : -1 --------------------------------------------------------------------------------- C1 : 1 C2 : 1 --------------------------------------------------------------------------------- C1 : 1 C2 : 2 --------------------------------------------------------------------------------- C1 : 1 C2 : 3 --------------------------------------------------------------------------------- C1 : 1 C2 : 4 --------------------------------------------------------------------------------- C1 : 1 C2 : 5 --------------------------------------------------------------------------------- C1 : 1 C2 : 6 --------------------------------------------------------------------------------- C1 : 1 C2 : 7 --------------------------------------------------------------------------------- C1 : 1 C2 : 8 --------------------------------------------------------------------------------- C1 : 1 C2 : 9 --------------------------------------------------------------------------------- C1 : 1 C2 : 10 --------------------------------------------------------------------------------- 11 row selected dbmMetaManager(DEMO)> select sum(c2) from t1 where c1 = 1; --------------------------------------------------------------------------------- SUM : 54.000000000 --------------------------------------------------------------------------------- 1 row selected
Decode( cond_expr, case_cond, value_expr, ..., [else_expr] )
cond_expr이 가진 값과 일치하는 case_cond 다음에 기술된 value를 반환한다. 만일 일치하는 경우가 없을 경우, else_expr이 존재하면 해당 값을 반환하며 그렇지 않으면 길이가 0인 값을 반환한다. cond_expr과 case_cond의 데이터 타입은 동일한데 double 또는 문자열을 사용할 수 있으며 반환되는 value_expr, else_expr은 문자열 데이터 타입이다.
사용 예
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int) success dbmMetaManager(DEMO)> insert into t1 values (1, 10) success dbmMetaManager(DEMO)> insert into t1 values (2, 20) success dbmMetaManager(DEMO)> insert into t1 values (3, 30) success dbmMetaManager(DEMO)> commit success dbmMetaManager(DEMO)> select c1, c2, decode( c1, 1, 'a', 2, 'b', 3, 'c', 'k' ) from t1 --------------------------------------------------------------------------------- C1 : 1 C2 : 10 DECODE : a --------------------------------------------------------------------------------- C1 : 2 C2 : 20 DECODE : b --------------------------------------------------------------------------------- C1 : 3 C2 : 30 DECODE : c --------------------------------------------------------------------------------- 3 row selected
Upper( expr )
주어진 문자열 expr이 text일 경우, 이를 대문자로 변환하여 반환한다.
사용 예
dbmMetaManager(DEMO)> select upper( 'aaaaabzc' ) from dual --------------------------------------------------------------------------------- UPPER : AAAAABZC --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select upper( 123 ) from dual --------------------------------------------------------------------------------- UPPER : 123 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select upper( 'a1b1C34' ) from dual --------------------------------------------------------------------------------- UPPER : A1B1C34 --------------------------------------------------------------------------------- 1 row selected
Lower( expr )
주어진 문자열 expr이 text일 경우, 이를 소문자로 변환하여 반환한다.
사용 예
dbmMetaManager(DEMO)> select lower( 'AAAAABZC' ) from dual --------------------------------------------------------------------------------- LOWER : aaaaabzc --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select lower( 123 ) from dual --------------------------------------------------------------------------------- LOWER : 123 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select lower( 'A1B1c34' ) from dual --------------------------------------------------------------------------------- LOWER : a1b1c34 --------------------------------------------------------------------------------- 1 row selected
NVL( orgnExpr, valueExpr)
주어진 문자열 orgnExpr의 첫 번째 byte가 NULL인 경우 ValueExpr로 변환된 값을 반환한다.
사용 예
dbmMetaManager(DEMO)> select nvl( 'x', 'not_null') from dual --------------------------------------------------------------------------------- NVL : x --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> select nvl( '', 'isnull') from dual --------------------------------------------------------------------------------- NVL : isnull --------------------------------------------------------------------------------- 1 row selected
JSON_STRING( Column_Name_List )
일반 테이블에 한해 전체 또는 주어진 column 목록에 해당하는 데이터들만 JSON 형태로 변환된 string을 반환한다.
사용 예
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int, c3 char(20) )
success
dbmMetaManager(DEMO)> insert into t1 values (1, 2, 'xyz1' )
success
dbmMetaManager(DEMO)> insert into t1 values (100, 200, 'zyx2' )
success
dbmMetaManager(DEMO)> insert into t1 values (10, 20, 'pppppppppp1' )
success
dbmMetaManager(DEMO)> commit
success
dbmMetaManager(DEMO)> select json_string(*) from t1
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "1", "C2": "2", "C3": "xyz1" }
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "100", "C2": "200", "C3": "zyx2" }
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "10", "C2": "20", "C3": "pppppppppp1" }
---------------------------------------------------------------------------------
3 row selected
dbmMetaManager(DEMO)> select json_string(c1, c2, c3) from t1
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "1", "C2": "2", "C3": "xyz1" }
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "100", "C2": "200", "C3": "zyx2" }
---------------------------------------------------------------------------------
JSON_STRING : { "C1": "10", "C2": "20", "C3": "pppppppppp1" }
---------------------------------------------------------------------------------
3 row selectedJSON_KEY(Column_Name, Path, Key_Length)
create index 구문에서 Json의 특정 값을 key로 사용할 때 사용한다. Path는 json path expression의 규칙을 따르지만 현재는 제한적으로 [](array), *(wildcard)만 사용할 수 있다.
Path는 '$.key1.key2'와 같이 single quote를 사용하여 입력하는데 depth는 dot으로 지정한다. 매칭되는 값이 없으면 NULL이 반환되고 그 외의 오류에 대해서는 에러를 반환한다. Path는 '$.key1.*', '$.*.key1' 등과 같은 wildcard를 지원한다. 매칭되는 값이 여러 개인 경우 어떤 값을 반환할지 정해지지 않은 상태이므로 이런 식의 사용은 권장하지 않는다. 현재 구조에서는 마지막으로 매칭되는 값을 반환하지만 버전이 바뀔 경우 반환되는 값도 바뀔수 있다. Path는 '$.key1[1].key2', '$.key1[*].key2' 처럼 array를 사용할 수 있다.
사용 예
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 char(400)); success dbmMetaManager(DEMO)> create unique index idx1_t1 on t1 ( json_key(c2, '$.key1', 32) ); success
JSON_VALUE( Column_Name, Path )
테이블에 저장된 Json text에서 path와 일치하는 필드를 찾아 그 값을 char 형태로 반환한다. Path와 일치하는 필드가 string이 아닌 경우에는 NULL을 반환한다. Path와 관련된 자세한 내용은 JSON_KEY(Column_Name, Path, Key_Length)를 참조한다.
사용 예
dbmMetaManager(DEMO)> insert into t1 values( 0,
'{
"key1":"100",
"key2":{"key3":"100"},
"key4":{"key41":"100", "key42":"100"},
"ARRAY":[{"ID":"1a"},{"ID":"2aa"},{"ID":"3aa"}]
}');
1 row selected
dbmMetaManager(DEMO)> select c1, json_value(c2, '$.key1') from t1 where c1 = 0;
---------------------------------------------------------------------------------
C1 : 0
JSON_VALUE : 100
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> delete from t1 where json_value(c2, '$.key1') = '100';
1 row deleted.JSON_QUERY( Column_Name, Path )
테이블에 저장된 Json text에서 path와 일치하는 필드를 찾아 그 값을 json 형태로 반환한다. Path와 일치하는 필드는 string type이 아니더라도 반환된다. Path에 대한 자세한 내용은 JSON_KEY(Column_Name, Path, Key_Length)를 참조한다.
사용 예
dbmMetaManager(DEMO)> insert into t1 values( 0,
'{
"key1":"100",
"key2":{"key3":"100"},
"key4":{"key41":"100", "key42":"100"},
"ARRAY":[{"ID":"1a"},{"ID":"2aa"},{"ID":"3aa"}]
}');
success
dbmMetaManager(DEMO)> select c1, json_query(c2, '$.key1') from t1 where json_value(c2, '$.key1') = '100';
---------------------------------------------------------------------------------
C1 : 0
JSON_QUERY : "100"
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select c1, json_query(c2, '$.key2') from t1 where c1 = 0;
---------------------------------------------------------------------------------
C1 : 0
JSON_QUERY : { "key3": "100" }
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select c1, json_query(c2, '$.ARRAY') from t1 where c1 = 0;
---------------------------------------------------------------------------------
C1 : 0
JSON_QUERY : [ { "ID": "1a" }, { "ID": "2aa" }, { "ID": "3aa" } ]
---------------------------------------------------------------------------------
1 row selected
dbmMetaManager(DEMO)> select c1, json_query(c2, '$.ARRAY[2]') from t1 where c1 = 0;
---------------------------------------------------------------------------------
C1 : 0
JSON_QUERY : { "ID": "3aa" }
---------------------------------------------------------------------------------
1 row selectedUSER_TYPE( Column_Name, Type_Name )
User type으로 지정된 column을 캐스팅하여 값을 출력한다.
사용 예
dbmMetaManager(DEMO)> select * from t2 --------------------------------------------------------------------------------- C1 : 100 C2 : 200 C3 : --------------------------------------------------------------------------------- C1 : 200 C2 : 300 C3 : --------------------------------------------------------------------------------- 2 row selected dbmMetaManager(DEMO)> select c1, c2, user_type(c3, u2) from t2 --------------------------------------------------------------------------------- C1 : 100 C2 : 200 USER_TYPE : C1=-100 C2=-200 --------------------------------------------------------------------------------- C1 : 200 C2 : 300 USER_TYPE : C1=-200 C2=-300 --------------------------------------------------------------------------------- dbmMetaManager(DEMO)> select user_type(c3, u2) from t2 where user_type(c3, u2.c1 ) = -100; --------------------------------------------------------------------------------- USER_TYPE : C1=-100 C2=-200 --------------------------------------------------------------------------------- 1 row selected
DICTIONARY
initdb를 통해 dictionary instance가 생성되면 자동으로 사용자 object를 관리하기 위한 dictionary table들이 생성된다. 본 절에서는 각 테이블들에 대해 설명한다.
DIC_INST
사용자가 생성한 instance 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
INIT_SIZE | 생성 시 초기 크기 (단위: undo page의 개수) |
EXTEND_SIZE | 공간 확장 시 크기 |
MAX_SIZE | 최대 확장 가능 크기 |
DIC_TABLE
사용자가 생성한 table 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
TABLE_NAME | Table name |
TABLE_TYPE | TABLE 유형
|
COLUMN_COUNT | TABLE을 구성하는 column의 개수 |
ROW_SIZE | TABLE에 저장되는 align된 레코드 크기의 합 |
MSG_SIZE | QUEUE TABLE인 경우 message의 최대 크기 |
INDEX_COUNT | 현재 테이블에 생성된 INDEX 개수 |
INIT_SIZE | 생성 시 초기 크기 (단위: 레코드 개수) |
EXTEND_SIZE | 공간 확장 시 크기 (단위: 레코드 개수) |
MAX_SIZE | 최대 확장 가능 크기 (단위: 레코드 개수) |
INDEX_ID | Index 생성 시점마다 부여되는 index 고유 번호 채번 |
DIC_COLUMN
Table을 구성하는 column 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
TABLE_NAME | Table name |
COLUMN_NAME | Column name |
USER_TYPE_NAME | User type으로 지정된 경우 해당 type name |
DATA_TYPE | Column의 데이터 타입
|
OFFSET | 레코드 전체 영역 중에 column이 저장되는 위치 |
SIZE | Column의 데이터 크기 |
COLUMN_ORDER | Column 순서 |
DIC_INDEX
테이블에 생성한 index의 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
TABLE_NAME | Table name |
INDEX_NAME | Index name |
IS_UNIQUE | Unique 여부
|
KEY_SIZE | Key column 크기의 합 |
KEY_COLUMN_COUNT | Key column의 총 개수 |
INDEX_ORDER | Index가 생성된 순서 |
DIC_INDEX_COLUMN
Index를 구성하는 key column의 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
TABLE_NAME | Table name |
INDEX_NAME | Index name |
COLUMN_NAME | Column name |
KEY_COLUMN_ORDER | Key column의 나열 순서 (Ordering 순서를 의미한다.) |
COLUMN_ORDER | 테이블 내의 column 순서 |
DIC_SEQUENCE
Sequence object를 구성하는 정보를 저장한다.
Column name | 설명 |
|---|---|
INST_NAME | Instance name |
SEQUENCE_NAME | Sequence name |
START_VALUE | 초기값 |
INCREMENT_VALUE | 증가값 |
CURRENT_VALUE | 미사용 column |
MIN_VALUE | MinValue |
MAX_VALUE | MaxValue |
IS_CYCLE |
|
Information View
GOLDILOCKS LITE의 상태 정보를 보여주기 위해 RDBMS 제품들과 유사한 view를 제공한다.
V$INSTANCE
현재 instance의 정보를 출력한다.
Column 이름 | 설명 |
|---|---|
SCN | 현재 instance의 SCN 값 |
MIN_SCN | System이 인지한 minSCN 값 |
CURR_MIN_SCN | 조회 시점의 실제 minSCN 값 |
MIN_SCN_TRANS_ID | 전체 transaction 중 가장 작은 SCN을 가진 TransId |
ACTIVE_MODE | Instance 활성화 여부 |
DISK_ENABLE | Disk LogFile 설정 여부 |
LOGFILE_SIZE | Disk LogFile 한 개의 크기 |
LOGCACHE_MODE | LogCache 설정 정보 |
LOGCACHE_CHUNK_SIZE | LogCache chunk 한 개의 크기 |
LOGCACHE_CHUNK_COUNT | LogCache chunk 최대 개수 |
LOGCACHE_RANGE | LogCache chunk의 사용 범위 |
CREATE_TIME | Instance를 생성한 시각 |
dbmMetaManager(DEMO)> select * from v$instance; --------------------------------------------------------------------------------- SCN : 11 MIN_SCN : 11 MIN_SCN_TRANS_ID : 1 ACTIVE_MODE : 1 DISK_ENABLE : 0 LOGFILE_SIZE : 0 LOGCACHE_MODE : no cache mode LOGCACHE_CHUNK_SIZE : 0 LOGCACHE_CHUNK_COUNT : 1 LOGCACHE_RANGE : 0 CREATE_TIME : 2020-03-25 12:57:02 ---------------------------------------------------------------------------------
V$SESSION
현재 instance에 attach되어 사용 중인 세션의 정보를 출력한다.
Column 이름 | 설명 |
|---|---|
TRANS_ID | Session 고유 ID 이다. |
PID | 현재 Trans Id를 점유하고 있는 OS process ID 이다. |
TID | 현재 Trans Id를 점유하고 있는 OS thread ID 이다. |
OLD_TID | 비정상 종료 시점에 할당된 OS thread ID 이다. |
CURR_UNDO_PAGE | 트랜잭션 진행 중에 사용되는 undo page의 현재 ID 이다. |
FIRST_UNDO_PAGE | 트랜잭션 진행 중에 사용되는 첫번째 undo page의 ID 이다. |
LAST_UNDO_PAGE | 트랜잭션 진행 중에 사용되는 마지막 undo page의 ID 이다. |
SAVEPOINT_UNDO_PAGE | 트랜잭션 진행 중 implicit savepoint가 필요한 경우 해당 위치를 가리킨다. |
SAVEPOINT_UNDO_OFFSET | 트랜잭션 진행 중 implicit savepoint가 필요한 경우 해당 위치를 가리킨다. |
WAIT_TRANS_ID | 대기 중일 경우 LOCK을 점유한 상대 Trans ID 이다. |
WAIT_OBJECT | 대기 중일 경우 대상 테이블 이름이다. |
WAIT_SLOT_ID | 대기 중일 경우 데이터 공간의 고유 ID 이다. |
STATUS | 트랜잭션의 현재 상태이다. |
IS_REPL | reserved |
BEGIN_TIME | 세션의 접속 시각이다. |
dbmMetaManager(DEMO)> select * from v$session; --------------------------------------------------------------------------------- TRANS_ID : 1 PID : 35612 TID : 35612 OLD_TID : 35612 CURR_UNDO_PAGE : 6 FIRST_UNDO_PAGE : 6 LAST_UNDO_PAGE : 11 SAVEPOINT_UNDO_PAGE : -1 SAVEPOINT_UNDO_OFFSE : -1 WAIT_TRANS_ID : -1 WAIT_OBJECT : WAIT_SLOT_ID : -1 STATUS : transaction ready or running IS_REPL : 0 BEGIN_TIME : 2020-03-25 12:57:04 ---------------------------------------------------------------------------------
V$TRANSACTION
세션들의 트랜잭션 진행 정보를 출력한다.
Column 이름 | 설명 |
|---|---|
TRANS_ID | Session 고유 번호 |
TRANS_SEQ | Session 내 트랜잭션 발생한 순서 |
TRANS_TYPE | 트랜잭션 유형 |
OBJECT_NAME | 대상 테이블 이름 |
SLOT_ID | 데이터 공간의 고유 ID |
EXTRA_KEY | 데이터 공간 내부 관리를 위한 고유 ID |
COMMIT_FLAG | 트랜잭션의 memory commit 여부 (1: Commit) |
SKIP_FLAG | 트랜잭션이 commit 되지 않도록 설정된 flag (1: Skip) |
VALID_FLAG | 트랜잭션 로그의 유효성 (1: 정상) |
V$LOG_STAT
DISK_LOG_ENABLE로 설정하여 운영할 경우 관련된 disk logfile과 checkpoint와 관련된 정보를 출력한다.
Column 이름 | 설명 |
|---|---|
DISKLOG_ENABLE | Disk logging 설정 여부 |
ARCHIVE_ENABLE | Archive 설정 여부 |
CURR_FILE_NO | Reserved |
CURR_FILE_OFFSET | Reserved |
LAST_CKPT_FILE_NO | CheckPoint가 수행될 logfile의 시작 번호 |
LAST_ARCHIVE_FILE_NO | Archive가 시작될 대상 logfile 번호 |
LAST_CAPTURE_FILE_NO | unused |
LOGCACHE_WRITE_IND | LogCache 공간 중 트랜잭션이 기록할 수 있는 현재 위치 |
LOGCACHE_READ_IND | LogCache 공간 중 flusher가 읽을 현재 위치 |
FLUSHER_FILE_NO | Flushser가 마지막으로 기록한 logfile의 번호 |
FLUSHER_FILE_OFFSET | Flushser가 마지막으로 기록한 logfile의 offset |
LOG_DIR | Disk LogFile이 저장되는 경로 |
ARCHIVE_DIR | Checkpoint시점에 archiving 될 logfile이 저장될 경로 |
dbmMetaManager(DEMO)> select * from v$log_stat; --------------------------------------------------------------------------------- DISKLOG_ENABLE : 0 ARCHIVE_ENABLE : 0 CURR_FILE_NO : -1 CURR_FILE_OFFSET : -1 LAST_CKPT_FILE_NO : -1 LAST_ARCHIVE_FILE_NO : -1 LAST_CAPTURE_FILE_NO : -1 LOGCACHE_WRITE_IND : -1 LOGCACHE_READ_IND : -1 FLUSHER_FILE_NO : -1 FLUSHER_FILE_OFFSET : -1 LOG_DIR : /home/lim272/4th_iter/pkg/wal ARCHIVE_DIR : ---------------------------------------------------------------------------------
V$SYS_STAT
Instance가 생성된 후에 발생한 각 유형별 수행 횟수에 대해 누적된 정보를 출력한다.
Column 이름 | 설명 |
|---|---|
NAME | 누적 유형의 이름 |
ACCUM_COUNT | 누적 수치 |
dbmMetaManager(DEMO)> select * from v$sys_stat --------------------------------------------------------------------------------- NAME : init_handle_op ACCUM_COUNT : 2 --------------------------------------------------------------------------------- NAME : free_handle_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- NAME : prepare_op ACCUM_COUNT : 20 --------------------------------------------------------------------------------- NAME : execute_op ACCUM_COUNT : 20 --------------------------------------------------------------------------------- NAME : insert_op ACCUM_COUNT : 2 --------------------------------------------------------------------------------- NAME : update_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- NAME : delete_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- NAME : scan_op ACCUM_COUNT : 3 --------------------------------------------------------------------------------- NAME : enqueue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : dequeue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : aging_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : commit_op ACCUM_COUNT : 11 --------------------------------------------------------------------------------- NAME : rollback_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- NAME : recovery_rollback_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : recovery_commit_op ACCUM_COUNT : 0 ---------------------------------------------------------------------------------
누적 항목에 대한 표는 다음과 같은데 v$sess_stat에서의 항목도 동일하다. 각 항목의 누적 수치는 성공/실패와 상관 없이 내부 처리 과정에 진입한 횟수를 의미한다.
누적 항목 | 설명 |
|---|---|
init_handle_op | Instance에 D/A mode로 접속한 횟수 |
free_handle_op | Instance에서 해제된 횟수 |
prepare_op | prepare statement가 호출된 횟수 |
execute_op | execute statement가 호출된 횟수 |
insert_op | insert가 수행된 횟수 |
update_op | update가 수행된 횟수 |
scan_op | select를 포함하여 대상을 scan하는 모든 횟수 |
delete_op | delete가 수행된 횟수 |
enqueue_op | enqueue가 수행된 횟수 |
dequeue_op | dequeue가 수행된 횟수 |
aging_op | 참조되지 않는 공간을 회수하는 과정이 처리된 횟수 |
commit_op | commit이 호출된 횟수 |
rollback_op | rollback이 호출된 횟수 |
recovery_rollback_op | 비정상 복구 (rollback과 동일한 과정)를 수행한 횟수 |
recovery_commit_op | 비정상 복구 (기존에 commit 된 row에 대한 lock을 해제하는 과정)를 수행한 횟수 |
V$SESS_STAT
Instance가 생성된 후에 발생한 세션 번호에 기록된 유형별 수행 횟수에 대해 누적된 정보를 출력한다. 이 정보는 세션에 접속한 이후의 정보가 아닌 누적치를 의미한다. 따라서 분석이 필요한 경우 before/ after와 같이 스냅샷을 조회하여 비교해야 접속 후의 변경량을 추정할 수 있다.
Column 이름 | 설명 |
|---|---|
TRANS_ID | 세션의 고유번호 |
NAME | 누적 유형의 이름 |
ACCUM_COUNT | 누적 수치 |
dbmMetaManager(DEMO)> select * from v$sess_stat --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : init_handle_op ACCUM_COUNT : 2 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : free_handle_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : prepare_op ACCUM_COUNT : 21 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : execute_op ACCUM_COUNT : 21 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : insert_op ACCUM_COUNT : 2 --------------------------------------------------------------------------------- TRANS_ID : 1633972341 NAME : te_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : delete_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : scan_op ACCUM_COUNT : 3 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : enqueue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : dequeue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : aging_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : commit_op ACCUM_COUNT : 11 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : rollback_op ACCUM_COUNT : 1 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : recovery_rollback_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- TRANS_ID : 1 NAME : recovery_commit_op ACCUM_COUNT : 0 ---------------------------------------------------------------------------------
dbmMetaManager 명령어
dbmMetaManager는 DDL/ DML/ DCL을 interactive하게 수행하여 사용자가 별도의 프로그램을 작성하지 않고도 테스트할 수 있는 utility이다. 본 절에서는 dbmMetaManager에서만 동작하는 명령어에 대해 설명한다.
입력 옵션 | 설명 |
|---|---|
-i <Instance name> | 특정 instance name을 지정 |
-f <script file> | 특정 script file 내의 SQL을 순차적으로 실행 후 종료 |
-p <nick name> | dbmMetaManager가 구분되도록 별칭을 지정 |
list
현재 접속된 instance 이하의 object 목록을 출력한다.
dbmMetaManager(DEMO)> list; OBJECT MAX TOTAL USED FREE ============================================================================= DUAL 102400 1024 1 1023 REPL_LOG 10000000 1024 0 1024 REPL_UNSENT 10000000 1024 0 1024 SEQ1 1 1 0 1 success
MVCC 방식으로 운영되는 경우, 실제 사용공간 중 일부는 aging 대상으로만 존재할 수 있기 때문에 version-2와 달리 USED/FREE의 표시 부분이 실제 레코드 개수와 다를 수 있다.
USED는 실제 데이터와 aging 대상 공간의 합계로 해석해야 한다.
desc
테이블의 생성 정보를 화면에 출력한다.
dbmMetaManager(DICT)> desc dic_index_column; ------------------------------------------------------------------------------------- Instance=(DICT) Table=(DIC_INDEX_COLUMN) Type=(TABLE) RowSize=(136) ------------------------------------------------------------------------------------- INST_NAME char 32 0 TABLE_NAME char 32 32 INDEX_NAME char 32 64 COLUMN_NAME char 32 96 KEY_COLUMN_ORDER int 4 128 COLUMN_ORDER int 4 132 ------------------------------------------------------------------------------------- IDX_DIC_INDEX_COLUMN unique (INST_NAME, TABLE_NAME, INDEX_NAME, COLUMN_NAME, KEY_COLUMN_ORDER) ------------------------------------------------------------------------------------- success
set index
테이블을 조회할 때 특정 index를 지정한다.
dbmMetaManager(DEMO)> create table t1 (c1 int, c2 int) success dbmMetaManager(DEMO)> create unique index idx1_t1 on t1 (c1) success dbmMetaManager(DEMO)> create unique index idx2_t1 on t1 (c2) success dbmMetaManager(DEMO)> insert into t1 values (1, 10) success dbmMetaManager(DEMO)> insert into t1 values (2, 20) success dbmMetaManager(DEMO)> select * from t1 where c2 = 20 Access Count = 2 --------------------------------------------------------------------------------- C1 : 2 C2 : 20 --------------------------------------------------------------------------------- 1 row selected dbmMetaManager(DEMO)> set index t1 idx2_t1 success dbmMetaManager(DEMO)> select * from t1 where c2 = 20 --------------------------------------------------------------------------------- C1 : 2 C2 : 20 --------------------------------------------------------------------------------- 1 row selected
set vertical [on/off]
dbmMetaManager 조회 결과는 기본적으로 column 별로 한 줄씩 출력된다. set vertical option을 통해 한 개 레코드 단위로 출력할 수 있다.
dbmMetaManager(DEMO)> set vertical off
success
dbmMetaManager(DEMO)> select * from t1
---------------------------------------------------------------------------------
C1 C2 C3 C4
---------------------------------------------------------------------------------
1 1 sunjesoft 1
1024 1024 hey hey hey 1024
---------------------------------------------------------------------------------
2 row selectedOS Command 수행
dbmMetaManager에서 shell command 등을 수행할 필요가 있을 때는 +를 표기한 후에 명령어를 기술한다. 다음 예제를 참고한다.
dbmMetaManager(unknown)> + ls -lrt ${DBM_HOME};
합계 12
drwxrwxr-x. 2 lim272 lim272 4096 12월 5 12:59 sample
drwxrwxr-x. 2 lim272 lim272 136 12월 11 15:58 conf
drwxrwxr-x. 2 lim272 lim272 177 12월 19 10:47 include
drwxrwxr-x. 2 lim272 lim272 27 12월 19 10:47 lib
drwxrwxr-x. 2 lim272 lim272 4096 12월 19 10:47 bin
drwxrwxr-x. 2 lim272 lim272 4096 12월 19 11:19 trc
drwxrwxr-x. 2 lim272 lim272 6 12월 19 11:37 arch
drwxrwxr-x. 2 lim272 lim272 6 12월 19 11:43 wal
drwxrwxr-x. 2 lim272 lim272 169 12월 19 11:48 dbf
drwxrwxr-x. 2 lim272 lim272 66 12월 19 11:49 repl
success원격 연결
dbmMetaManager에서 원격으로 연결해야 할 경우 다음과 같이 수행한다. 이 경우, 원격지에 dbmListener가 구동된 상태이어야 한다.
Connect := CONNECT <remote ip> <remote listen portNo> <instance>
다음은 Listener에 접속하여 instance를 생성하는 예이다.
dbmMetaManager(unknown)> connect 127.0.0.1 27584 dict success dbmMetaManager(127.0.0.1:DICT)> create instance demo success
C Type 구조체 출력
현재 생성되어 있는 테이블에 대한 C Type 구조체 형태를 출력한다.
dbmMetaManager(DEMO)> create table t1
(c1 int, c2 short, c3 long, c4 float, c5 double, c6 date, c7 char(33) );
success
dbmMetaManager(DEMO)> struct out t1;
typedef struct T1
{
int C1;
short C2;
long long C3;
float C4;
double C5;
struct timeval C6;
char C7[33];
} T1
success복구 가이드
GOLDILOCKS LITE는 shared memory를 기반으로 하므로 OS fatal/ memory fault 상태가 발생하지 않으면 모든 데이터가 메모리상에 존재한다. 따라서 데이터 자체는 유실되지 않지만 전원 OFF 등으로 인한 장애로 인해 사용 환경에 따라 데이터 복구가 필요할 수 있다. 본 장에서는 이런 경우에 대비하여 사용자가 디스크 로깅과 데이터 파일을 이용하여 복구하는 방법을 설명한다.
디스크 로깅은 instance 생성 시점의 프로퍼티에 의해 설정되며 프로퍼티를 변경할 경우 instance를 재생성해야 하기 때문에 운영 전에 충분히 고려하여 프로퍼티를 설정해야 한다.
일시적 백업/ 복구
운영 중에 정기적인 PM 작업 등으로 인해 서버 전원을 차단해야 할 경우에 대비하여 전체 object/ data를 plain text 형태로 내려받는 tool (dbmExp)을 제공한다. 해당 tool을 이용하여 데이터를 백업한 후 서버 작업이 마무리되면 dbmExp를 통해 받은 파일을 이용하여 전체 object/ data를 복구할 수 있다.
[lim272@tech10 src]$ dbmExp -h Usage] dbmExp <-i> <-t> <-r> <-c> <-d> -i : specify a instance name to export -t : specify a table name to export. (export all tables if exclude) -r : specify a row delimeter when export data -c : specify a column delimeter when export data -d : use this option if need data-exporting -h : Display this information
다음은 전체 instance의 모든 object/ data를 내려받는 예이다.
[lim272@tech10 tmp]$ dbmExp -d [ DEMO ] Instance start... + (T1) (10 rows) download + (T2) (10 rows) download + (T3) (10 rows) download + (T4) (10 rows) download + (T5) (12 rows) download
dbmExp를 수행하면 작업 경로 내에 다음과 같은 형태의 파일이 생성되는데 sql 파일들은 object를 생성할 SQL 구문을 포함한다. dat 파일들은 각 테이블별 데이터를 저장하고 있다. 복구할 때는 *_create.sql 파일을 이용하여 object들을 생성한 후 *_in.sh을 수행하여 데이터를 다시 메모리에 로딩할 수 있다.
-rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_T1.fmt -rw-rw-r--. 1 lim272 lim272 10221 Jun 24 14:38 DEMO_T1.dat -rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_T2.fmt -rw-rw-r--. 1 lim272 lim272 10221 Jun 24 14:38 DEMO_T2.dat -rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_T3.fmt -rw-rw-r--. 1 lim272 lim272 10221 Jun 24 14:38 DEMO_T3.dat -rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_T4.fmt -rw-rw-r--. 1 lim272 lim272 10221 Jun 24 14:38 DEMO_T4.dat -rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_T5.fmt -rw-rw-r--. 1 lim272 lim272 1485 Jun 24 14:38 DEMO_create.sql -rw-rw-r--. 1 lim272 lim272 12265 Jun 24 14:38 DEMO_T5.dat -rw-rw-r--. 1 lim272 lim272 180 Jun 24 14:38 DEMO_in.sh -rw-rw-r--. 1 lim272 lim272 20 Jun 24 14:38 DEMO_create_proc.sql
디스크 로깅
디스크 로깅 방식은 기본적으로 트랜잭션의 commit 된 log를 disk에 모두 기록한다. 각 방식에 따라 세 가지 모드로 설정할 수 있다.
DBM_LOG_CACHE_MODE | 설명 |
|---|---|
NONE (0) | 각 세션별로 parallel 하게 디스크 로그 파일에 commit log를 기록한다. |
NVDIMM (1) | NVDIMM 매체에 commit log를 기록한다. 디스크로 저장되는 작업은 별도의 프로세스가 처리하기 때문에 트랜잭션이 디스크 기록까지 대기하지 않는다. |
SHM (2) | Shared memory를 이용하여 commit log를 기록한다. |
Non-volatile Dual Inline Memory Module (NVDIMM)은 비휘발성 메모리 매체를 의미하는데 서버 전원이 갑자기 OFF 되더라도 자체 배터리와 SSD를 이용하여 NVDIMM 내에 저장된 데이터가 유실되지 않도록 보장하는 장치이다.
NVDIMM/ SHM 모드를 설정하면 제한된 메모리 공간을 이용하여 commit log를 기록하는데 이를 실제 디스크로 저장하려면 dbmLogFlusher라는 daemon을 구동시켜야 한다. dbmLogFlusher는 NVDIMM/ SHM 공간에 저장된 내용을 디스크 로그 파일로 저장한다.
디스크 저장은 일반적으로 process에서 kernel-buffer까지 또는 process에서 disk cache, physical disk까지 sync하는 두 가지 방식으로 동작하며 이러한 동작을 위해 GOLDILOCKS LITE는 DBM_COMMIT_WAIT_MODE 설정이 가능하도록 지원한다. 이 프로퍼티는 성능 본위의 제품 특성상 비활성화되어 있는데 활성화시킬 경우 DISK까지 sync를 보장한다. 다만 이 속성의 활성화는 결과적으로 안정성 보장만 목표로 하기 때문에 DML 성능은 효과적으로 발휘할 수 없게 된다.
체크포인트
GOLDILOCKS LITE는 디스크 로깅을 활성화했을 때 로그 파일을 계속 증가시키는 방식으로 파일을 생성/ 추가한다. 따라서 주기적으로 체크포인트를 수행하여 데이터 파일을 만들고 복구에 필요하지 않은 로그 파일을 삭제하여 디스크 사용 공간이 계속 증가되지 않도록 할 수 있다.
dbmCkpt daemon process는 체크 포인트를 담당하며 지정된 경로에 생성되는 로그 파일을 감지하여 데이터 파일에 commit log를 반영하고 반영 완료된 로그 파일을 archive 경로로 옮기거나 삭제하는 동작을 수행한다. 대량의 I/O가 발생할 수 있으므로 cron-tab 등에 주기를 설정하여 동작시키는 것이 바람직하며 이 때 해당 주기 동안 축적되는 로그 파일로 인해 디스크 용량 부족 등이 발생하지 않도록 해야 한다.
복구
디스크 로그와 체크포인트로 운영할 경우, 전원 OFF 후 복구 시점에 다음과 같이 복구할 수 있다.
~work> dbmCkpt -i demo -f ~work> dbmMetaManager dbmMetaManager(unknown)> startup; success
반드시 dbmCkpt를 먼저 수행해야 하는데 이는 마지막 체크포인트부터 반영되지 않은 로그 파일을 데이터 파일에 반영해야 가장 최신 데이터로 데이터 파일을 만들 수 있기 때문이다. 그 다음 dbmMetaManager를 수행하여 startup 명령을 통해 복구를 수행한다. Startup 과정은 기존에 존재하던 object/ data를 마지막 시점까지 복구하는 일련의 과정을 모두 수행한다. 생성되는 데이터는 데이터 파일을 기준으로 적재되기 때문에 마지막으로 수행한 체크포인트 시점까지 반영된 데이터 파일을 기준으로 적용된다.
운영 중 복구 과정에서 마지막 체크포인트를 강제로 수행하지 못하고 실수로 startup 했다면 기존의 shared memory를 제거한 후 다시 체크포인트 수행하고 startup 하면 최종본까지 데이터를 복구할 수 있다. (기존의 shared memory만 잘 제거된 상태라면 startup은 반복적으로 수행해도 된다.)
Utility
GOLDILOCKS LITE에서 제공하는 사용자 utility에 대해 설명한다.
dbmExp
GOLDILOCKS LITE 내의 object 생성과 관련된 script와 데이터를 추출하는 utility 이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance Name> | 특정 instance를 지정할 경우에 입력한다. 입력하지 않을 경우, 전체를 추출한다. |
-t <table Name> | 특정 table을 지정할 경우에 입력한다. 입력하지 않을 경우 전체를 추출한다. |
-r <delimeter> | 데이터 추출 옵션이 활성화 된 경우 레코드 단위 구분자를 지정한다. |
-c <delimeter> | 데이터 추출 옵션이 활성화 된 경우 column 단위 구분자를 지정한다. |
-d | 데이터를 추출하고자 할 경우에 입력한다. |
-b | LITE간 binary 형태로 데이터를 추출할 경우에 입력한다. 추후 dbmImp로 로딩할 때 parsing 비용을 줄일 수 있다. (타 DBMS와는 호환 불가한 형식이다.) |
dbmExp에 의해 추출된 데이터는 plain text로 저장되며 다른 DBMS로 데이터를 이관하여 사용할 수도 있다.
csv 형태 추출을 지원하는데 이 경우 별도 옵션없이 사용자가 row와 column 구분자를 지정하지 않아야 한다.
사용 예 (특정 instance의 하위 object와 데이터 추출)
$ dbmExp -i demo -d [ DEMO ] Instance start... + (QUE1) (1 rows) download + (T1) (1 rows) download
생성되는 각 파일 이름은 INSTANCENAME_OBJECTNAME와 같은 형식이다.
데이터 추출 옵션이 활성화되면 form file을 생성한다.
Sequence는 current 값을 start with 값으로 설정하여 출력한다.
dbmExp 추출 결과물
dbmExp를 통해 아래의 표와 같은 script 결과물이 생성된다. 생성되는 script 파일 형식은 <INSTANCE_NAME>_xxx.sh(sql) 이다.
File name | 설명 |
|---|---|
DEMO_create.sql | Table, queue, index와 같이 데이터를 저장하는 object를 생성하는 스크립트를 저장한다. |
DEMO_create_proc.sql | Procedure 생성 스크립트를 저장한다. |
DEMO_in.sh | 모든 테이블의 데이터를 로딩하는 명령어를 저장한다. |
dbmImp
dbmExp를 통해 추출된 데이터 또는 다른 DBMS로부터 추출된 구분자를 가진 text 형태의 데이터를 분석하여 적재하는 utility 이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance Name> | 대상 instance name을 지정한다. |
-t <table Name> | 대상 table name을 지정한다. |
-r <delimeter> | 레코드 단위 구분자를 지정한다. |
-c <delimeter> | Column 단위 구분자를 지정한다. |
-d <data file name> | 데이터 파일 이름을 지정한다. |
-f <form file name> | Form file 이름을 지정한다. |
-b | 데이터 파일이 dbmExp에 의해 만들어진 binary format일 경우에 지정한다. (Parsing 비용을 줄일 수 있다.) |
Form file 정보를 수정하여 특정 column을 올리지 않거나 순서를 변경하여 데이터를 축적할 수 있다.
특수 문자로 제공되는 구분자는 다음과 같다.
구분자 | Ascii 값 | 입력방식 (on dbmImp) |
|---|---|---|
| 9 |
|
| 13 |
|
| 10 |
|
사용 예 (TABLE, QUEUE에 데이터 축적)
$ dbmImp -i demo -t t1 -d DEMO_T1.dat (DEMO.T1) Import Success. (ReadCount=1, Inserted=1) $ dbmImp -i demo -t que1 -d DEMO_QUE1.dat (DEMO.QUE1) Import Success. (ReadCount=1, Inserted=1)
추출된 form file을 이용하여 데이터에 존재하는 특정 column을 올리지 않으려면 Y 항목을 N으로 변경한다.
$ cat DEMO_T1.fmt
C1 Y
C2 Y
C3 Y
C4 Y
C5 Y
C6 Y 1 N 으로 변경
C7 Y
C8 Y
C9 Y
C10 Y데이터 파일에 C2, C3 column이 없다면 위 예제에서는 C2, C3 line을 제거한 후에 수행한다.
데이터 파일에 C2, C3 column의 순서가 바뀌어 저장된 경우, C2, C3 line을 서로 바꾸어 처리한다.
DATE 타입은 기본적으로 YYYY/MM/DD HH:MI:SS.SSSSSS 형태의 문자열을 기반으로 데이터를 해석하기 때문에 다른 DBMS에서 데이터를 추출하여 올려야 할 경우 해당 DBMS에서 동일한 형식으로 DATE를 문자열로 추출해야 한다.
dbmCkpt
DISK mode가 활성화된 상태에서 GOLDILOCKS LITE을 운영할 경우, 트랜잭션 정보를 저장한 logfile을 생성한다. 이 로그 파일은 영구적으로 증가하기 때문에 이를 제거하고 데이터 파일을 구성할 방법이 필요한데 dbmCkpt가 이런 역할을 수행한다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다. |
-v | 한 번만 수행한 후에 종료한다. |
-f | 체크포인트 대상 logfile이 다 쓰여지지 않은 상태라도 강제로 체크포인트를 수행할지 여부를 지정한다. (Startup 직전 수행시점에 반드시 옵션을 포함한 체크포인트가 필요하다.) |
-s | 체크포인트를 수행한 후에 지정된 시간만큼 대기한다. (단위: 초) |
체크포인트를 수행하면 다량의 disk I/O가 발생하여 성능에 영향을 줄 수 있기 때문에 crontab 등에 주기적으로 동작하도록 설정하거나 sleep interval을 명시하여 수행 주기를 지정해야 한다.
dbmCkpt 환경에서 데이터 복구
dbmCkpt를 사용하는 환경에서는 특정 시점에 체크포인트를 진행하여 반영된 데이터 파일과 이 과정에서 발생하는 데이터 파일에 미반영된 트랜잭션 로그 파일을 이용하여 최종 상태로 복구할 수 있다. 따라서 사용자가 다음 절차를 수행하면 shared memory가 유실되었더라도 데이터를 원래의 상태로 복원할 수 있다.
Force mode를 지정하여 dbmCkpt를 수행한다. (-f 옵션 사용)
Prompt> dbmCkpt -i demo -f -v
이 다음에 수행하는 startup 단계에서는 현재까지 반영된 데이터 파일을 기준으로 데이터를 로딩하기 때문에 마지막 체크포인트 시점부터 미반영된 트랜잭션 로그 내역은 아직 반영되지 않은 상태이다. 따라서 사용자가 임의로 체크포인트를 수행하여 미반영된 트랜잭션 로그를 반영하는 과정을 수행해야 한다.
startup을 수행한다.
dbmMetaManager(unknown)> startup;
현재의 데이터파일 이미지로 테이블/ index/ 데이터 등을 메모리에 원래의 상태로 복원한다.
Archive Log를 통한 데이터 파일 복구
데이터 파일이 삭제되었을 때 archive 방식이 아닐 경우 데이터는 복구할 수 없다. 그러나 archive 방식을 사용한 경우에는 checkpoint가 수행된 로그 파일도 archive directory에 보관되어 있으므로 이를 통해 데이터를 복구할 수 있다.
1. Checkpoint 시작 위치를 reset 한다.
dbmMetaManager> alter system reset checkpoint demo -1;
이 명령은 현재 log anchor file 정보가 유효할 때 실행한 것이며 그렇지 않다면 shared memory가 삭제된 상태일 것이다. 이 경우 object 생성까지만 수행하므로 이 단계는 수행하지 않아도 된다.
2. Force mode로 dbmCkpt를 수행한다.
Prompt> dbmCkpt -i demo -f -v
3. Startup을 수행한다.
dbmMetaManager(unknown)> startup;
Dictionary datafile들인 "DIC_"를 prefix로 갖는 파일들이 손상되거나 유실된 경우에는 수동으로 object를 생성한 후 위의 복구 과정을 수행해야 한다. 단, 생성할 때 새로운 로그가 checkpoint에 적용되면 안되므로 object를 생성하는 세션은 DBM_DISK_LOG_ENALBE을 false 상태로 두고 접속해야 한다.
dbmDump
dbmDump는 여러 세트먼트와 파일을 dump하는 tool이다. 옵션과 파일 타입에 따라 해당되는 내용을 dump한다.
dbmDump (Instance)
Instance dump: Instance에서는 접근하는 session의 상태 정보와 트랜잭션의 진행 상태를 기록하고 있다. dbmDump (Instance)는 이런 상태 정보를 출력하여 문제가 될 만한 session을 trace 하기 위한 용도로 제공한다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다. |
-t <session ID> | 특정 session ID와 관련된 정보만 출력할 경우에 지정한다. |
사용 예
$ dbmDump -i demo InstName=DEMO, TransId=-1 Lock=-1, SCN=3000010, mSeed=0, ObjectId=0, Name=DEMO, CreateTime=2019-01-02 18:12:44 ============================================================================================================ TxInfo(T=1, P:48890, T=48890), Stat=transaction ready or running, First/Last(26:26), SavePoint(-1:-1) WaitTrans=-1, SCN=-1 Page=26, PrevOffset=-1, Offset=32, NextLogPage=26, NextLogOffset=280, Size=104, LogType=LOCK_ROW, RelSlot=1, ObjectName=(T1,) NeedSkip=0, Valid=1, MemCommit=0 Page=26, PrevOffset=32, Offset=280, NextLogPage=-1, NextLogOffset=-1, Size=104, LogType=UPDATE_TABLE, RelSlot=1, ObjectName=(T1,) NeedSkip=0, Valid=1, MemCommit=0
dbmDump (Instance)는 instance header 정보와 각 session 별 트랜잭션 정보를 출력한다. Instance header에 해당하는 정보들은 다음 표와 같다.
항목 | 설명 |
|---|---|
Lock | Instance lock 설정 여부 |
SCN | System commit number 용도 |
mSeed | Reserved |
ObjectId | Reserved |
CreateTime | Instance 생성 시각 |
Session 별 트랜잭션 출력 정보는 다음과 같으며 트랜잭션 수행 순서대로 출력된다. Session의 master 정보는 다음 표와 같다.
항목 | 설명 |
|---|---|
TxInfo( T: P: T) | Session 정보
|
Stat | 트랜잭션 상태
|
First/ Last | Session이 사용 중인 undo 공간의 첫 번째와 마지막 PageId |
SavePoint | 트랜잭션이 진행되는 도중에 기록되는 implicit savepoint 정보 |
WaitTrans | 트랜잭션이 LockWait 상태일 경우에 대기하는 상대편 SessionID |
SCN | Commit 시점에 채번된 SCN |
Session 별로 출력되는 트랜잭션 로그는 다음 표와 같다.
항목 | 설명 |
|---|---|
Page | 현재 트랜잭션 로그가 기록된 현재 page ID |
PrevOffset | 이전 트랜잭션 로그가 기록된 page 내의 offset 정보 |
Offset | 현재 트랜잭션 로그가 기록된 page 내의 offset 정보 |
NextLogPage | 다음 트랜잭션 로그가 기록된 page ID |
NextLogOffset | 다음 트랜잭션 로그가 기록된 page 내의 offset 정보 |
Size | Rollback image의 크기 |
LogType | 트랜잭션 로그 유형 |
RelSlot | Table내에 고유 레코드 ID |
ObjectName | 트랜잭션이 발생한 object name |
NeedSkip | Partial rollback등으로 트랜잭션 로그가 무효화되는 경우에 1로 설정된다. |
Valid | 아직 로그 기록이 완료되기 전이거나 partial rollback 등으로 인해 트랜잭션 로그가 무효화 될 경우 0으로 설정된다. |
MemCommit | Commit 과정에서 메모리 반영이 완료된 로그일 경우 1로 설정된다. |
dbmDump (Anchor)
Anchor 파일의 이상 유무를 추적하는 tool이다
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-f <anchor filename> | 대상 anchor filename을 지정한다 |
사용 예
$ dbmDump (Anchor) -f pkg/wal/DEMO.anchor TransId=1, LogFileNo(0:3072), ArchiveStartFile(-1), MinCkptFileNo(-1), CaptureFileNo(-1) LogCache: WriteInd=0, ReadInd=0, LogFileNo=0, Offset=0
dbmDump (Datafile)
Datafile의 이상 유무를 추적하는 tool 이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-f <data filename> | 대상 data filename을 지정한다 |
사용 예
$ dbmDump -f pkg/dbf/DEMO_T1.dbf InstName=DEMO, TableName=T1, SlotSize=2128, CreateSCN=300010 ColumnName (C1), Order=1, Type=int, Offset=0, Size=4 ColumnName (C2), Order=2, Type=int, Offset=4, Size=4 ColumnName (C3), Order=3, Type=char, Offset=8, Size=2048 Dump (pkg/dbf/DEMO_T1.dbf) completed
dbmDump (Index)
Index의 이상 유무를 추적하는 tool 이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
-t <table name> | 대상 table name을 지정한다 |
-d <index name> | 대상 index name을 지정한다 |
사용 예
$ dbmDump -i demo -t t1 -d idx1_t1
InstName=DEMO, TableName=T1, IndexName=IDX1_T1
try to attach a index segment
Lock=-1, RootNodeId=-1, Unique=1, WorkType=0, mBeforeNewNodeToSplit=-1, mBeforeSrcNodeToSplit=-1, BeforeParent=-1
OldNewNodeToSplit=-1, OldSrcNodeToSplit=-1, OldParentNode=-1
mBeforeRemoveNodeId=-1, mRecoveryTID=-1dbmDump (Logfile)
로그 파일의 이상 유무를 추적하는 tool이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-f <log filename> | 대상 log filename을 지정한다 |
사용 예
$ dbmDump -f pkg/wal/DEMO.0.0 | tail BlockSCN=204796, BlockCount=1, logCount=1 + logType(DELETE_TABLE), object(T1), SlotId(4787) BlockSCN=204797, BlockCount=1, logCount=1 + logType(DELETE_TABLE), object(T1), SlotId(4788) BlockSCN=204798, BlockCount=1, logCount=1 + logType(DELETE_TABLE), object(T1), SlotId(4789) BlockSCN=204799, BlockCount=1, logCount=1 + logType(DELETE_TABLE), object(T1), SlotId(4790) BlockSCN=204800, BlockCount=1, logCount=1 + logType(DELETE_TABLE), object(T1), SlotId(4791)
dbmDump (Table)
테이블의 이상 유무를 추적하는 tool 이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
-t <table name> | 대상 table name을 지정한다 |
-s | slot-area 정보를 출력한다. |
사용 예
$ dbmDump -i demo -t T1 InstName=DEMO, TableName=T1, RowSize=2056, CreateTime=2020-02-11 12:47:18 1] C1 int(2) 4 0 2] C2 int(2) 4 4 3] C3 char(6) 2048 8
dbmListener
원격지에서 GOLDILOCKS에 접속하기 위해 실행해야 하는 통신 데몬 프로세스이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
-v | Non 데몬 모드로 구동된다. |
dbmListener를 구동한 후에 사용자가 접속하려면 다음과 같은 두 가지 방식으로 테스트해 볼 수 있다.
dbmMetaManager> connect <ip> <port> <instanceName> ;
또는
dbmConnect API 사용
관련 환경변수 | 비고 |
|---|---|
DBM_TCP_CONN_TIMEOUT | 지정된 시간 동안 연결에 성공하지 못하면 에러를 반환한다. (millisecond단위) |
DBM_TCP_RECV_TIMEOUT | Execution 도중에 지정된 시간 동안 응답을 받지 못하면 에러를 반환한다 (millisecond단위) |
DBM_LISTEN_PORT | LISTEN할 PortNo를 지정한다. |
dbmLogFlusher
Log cache를 사용할 때 disk에 log cache를 저장하는 데몬 프로세스이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
관련 환경변수 | 비고 |
|---|---|
DBM_LOG_CACHE_FLUSH_INTERVAL | Log cache가 flush되는 인터벌을 설정한다. (millisecond 단위) |
DBM_LOG_CACHE_EMPTY_INTERVAL | Log cache에 잘못된 값이 있어 skip 하는 인터벌을 설정한다. (millisecond 단위) |
dbmMonitor
GOLDILOCKS LITE의 상태를 모니터링 하는 데몬 프로세스이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
-s <interval time> | 모니터링 하는 interval 시간을 설정한다. (second 단위) |
-v | Non 데몬 모드로 구동된다. |
사용 예
$ dbmMonitor -i demo 2020/02/11 11:15:28 [Table Usage] TableName TotalSize AllocSize UsedSize FreeSize Usage ------------------------------------------------------------------------------------------------------- REPL_LOG 100000 1024 0 1024 0.00 REPL_UNSENT 1000000 1024 0 1024 0.00 T1 102400 1024 0 1024 0.00 ------------------------------------------------------------------------------------------------------- [Lock Status] WaitTransId WaitTransPID LockTransId LockTransPID LockObject LockSlot ------------------------------------------------------------------------------- no waiting trans -------------------------------------------------------------------------------
dbmReplica
GOLDILOCKS LITE의 이중화 방식은 active/ standby 구조로 동작한다. Standby (slave) 측에서 데이터를 수신/반영하기 위해 구동하는 프로세스가 dbmReplica이다.
Input Option
입력 옵션 | 설명 |
|---|---|
-h | 도움말을 출력한다. |
-i <instance name> | 대상 instance name을 지정한다 |
사용 예
$ dbmRepica -i demo
Sizing
GOLDILOCKS LITE를 사용하기 전에 필요한 sizing과 관련된 내용을 설명한다.
Instance Sizing
Instance는 rollback 하기 위해 before image를 저장하는 공간으로써 logging space는 1 page 당 1M이다. 이 공간에 N 개의 트랜잭션 로그를 기록하기 때문에 사용량은 가변적이며 확인할 수는 없다. 다만 instance segment의 크기는 아래의 수식을 통해 계산할 수 있다.
Instance Sizing = sizeof(segment Header) + // 240 byte
sizeof(trans Header) + // 753904 byte
sizeof(long long) * (init_size + 1) +
(1M * init_size)
;대량의 bulk update 등의 작업을 수행할 경우, instance 공간은 확장될 수 있고 최대 크기가 부족할 수 있다. 이런 bulk update는 GOLDILOCKS LITE의 특성과는 적합하지 않으나 부득이하게 실행해야할 경우, 미리 공간을 크게 설정해야 한다.
Table Sizing
Table은 실제 레코드가 저장되는 공간으로써 table header 공간 및 공간 관리를 위한 관리자 공간을 포함하여 각 record마다 기록되는 record header를 고려하여 sizing 해야 한다.
Table Sizing = sizeof(segment header) + // 240 byte
sizeof(table header) + // 82052 byte
sizeof(long long) * (init_size + 1) +
(72(Record Header) + RecordSize) * init_size
;init_size는 create table 시점에 지정한 option 값이다. Extend 된 segment는 init_size가 아닌 extent option 값으로 계산해야 한다.
Index Sizing
Index에는 별도의 공간을 설정하지 않고 table에 설정된 size에 key column의 key size를 계산하여 이를 최대 두 배수로 split 할 것을 가정한 공간을 설정한다. Splay, direct table 유형은 dummy index segment 만 만들기 때문에 sizing은 고려할 필요 없다.
Monitoring
본 장에서는 LITE를 실시간으로 모니터링하는 방법들에 대해 설명한다.
LOCK 정보 확인
모든 변경 연산들에 대해 record 단위로 lock을 점유하여 다른 세션으로부터의 데이터가 변경되지 않도록 보호한다. 정상적인 상황일 수도 있지만 사용자 실수로 commit/ rollback 하지 않아 장시간 대기하는 경우들을 찾기 위해 다음 방법을 사용한다.
V$SESSION 테이블에서 세션 중에 lock으로 인해 대기하는 경우는 다음과 같이 조회할 수 있다.
dbmMetaManager(DEMO)> select * from v$session where wait_trans_id <> -1; --------------------------------------------------------------------------------- TRANS_ID : 3 PID : 40832 TID : 40832 OLD_TID : 40832 VIEWSCN : 16 CURR_UNDO_PAGE : 30 FIRST_UNDO_PAGE : 30 LAST_UNDO_PAGE : 35 SAVEPOINT_UNDO_PAGE : 30 SAVEPOINT_UNDO_OFFSE : -1 WAIT_TRANS_ID : 2 WAIT_OBJECT : T1 WAIT_SLOT_ID : 512 STATUS : transaction ready or running IS_LOGGING : 0 IS_REPL : 0 BEGIN_TIME : 2021/04/16 13:25:05 --------------------------------------------------------------------------------- 1 row selected
위 결과에서 WAIT_TRANS_ID 항목이 -1이 아니라면 해당 TransID를 가진 세션을 기다리고 있는 상태라는 것을 의미한다. 대기 중인 대상 테이블은 T1 이고 512번 slot을 가진 record에서 대기하고 있다는 의미이다.
위의 예에서처럼 TransID=2인 세션이 무엇을 하고 있는지는 다음과 같이 조회할 수 있다.
bmMetaManager(DEMO)> select * from v$transaction where trans_id = 2; --------------------------------------------------------------------------------- TRANS_ID : 2 TRANS_SEQ : 1 TRANS_TYPE : LOCK_ROW OBJECT_NAME : T1 SLOT_ID : 0 EXTRA_KEY : 1 COMMIT_FLAG : 0 SKIP_FLAG : 0 VALID_FLAG : 1 --------------------------------------------------------------------------------- TRANS_ID : 2 TRANS_SEQ : 2 TRANS_TYPE : DELETE_TABLE OBJECT_NAME : T1 SLOT_ID : 0 EXTRA_KEY : 1 COMMIT_FLAG : 0 SKIP_FLAG : 0 VALID_FLAG : 1 --------------------------------------------------------------------------------- TRANS_ID : 2 TRANS_SEQ : 3 TRANS_TYPE : LOCK_ROW OBJECT_NAME : T1 SLOT_ID : 512 EXTRA_KEY : 513 COMMIT_FLAG : 0 SKIP_FLAG : 0 VALID_FLAG : 1 --------------------------------------------------------------------------------- TRANS_ID : 2 TRANS_SEQ : 4 TRANS_TYPE : INSERT_TABLE OBJECT_NAME : T1 SLOT_ID : 512 EXTRA_KEY : 513 COMMIT_FLAG : 0 SKIP_FLAG : 0 VALID_FLAG : 1 --------------------------------------------------------------------------------- 4 row selected
SlotID=512를 가진 record를 변경하고 있는 세션이며 아직 commit/ rollback을 하지 않아 현재 상태가 유지되고 있다. TransID=2를 가진 세션이 어떤 프로세스인지 v$session을 통해 다음과 같이 확인할 수 있다.
dbmMetaManager(DEMO)> select * from v$session where trans_id = 2; --------------------------------------------------------------------------------- TRANS_ID : 2 PID : 40656 TID : 40656 OLD_TID : 40656 VIEWSCN : 9223372036854775807 CURR_UNDO_PAGE : 24 FIRST_UNDO_PAGE : 24 LAST_UNDO_PAGE : 29 SAVEPOINT_UNDO_PAGE : -1 SAVEPOINT_UNDO_OFFSE : -1 WAIT_TRANS_ID : -1 WAIT_OBJECT : WAIT_SLOT_ID : -1 STATUS : transaction ready or running IS_LOGGING : 0 IS_REPL : 0 BEGIN_TIME : 2021/04/16 13:24:41 --------------------------------------------------------------------------------- 1 row selected
위의 예에서 PID=40656을 가진 프로세스라는 것을 확인할 수 있다.
처리량 확인
LITE는 각 주요 operation에 대한 누적 정보를 기록하고 있다. 다음과 같이 전체 누적량을 확인할 수 있다.
dbmMetaManager(DEMO)> select * from v$sys_stat; --------------------------------------------------------------------------------- NAME : init_handle_op ACCUM_COUNT : 6 --------------------------------------------------------------------------------- NAME : free_handle_op ACCUM_COUNT : 3 --------------------------------------------------------------------------------- NAME : prepare_op ACCUM_COUNT : 27 --------------------------------------------------------------------------------- NAME : execute_op ACCUM_COUNT : 27 --------------------------------------------------------------------------------- NAME : insert_op ACCUM_COUNT : 514 --------------------------------------------------------------------------------- NAME : update_op ACCUM_COUNT : 2 --------------------------------------------------------------------------------- NAME : delete_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : scan_op ACCUM_COUNT : 1029 --------------------------------------------------------------------------------- NAME : enqueue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : dequeue_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : aging_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : commit_op ACCUM_COUNT : 16 --------------------------------------------------------------------------------- NAME : rollback_op ACCUM_COUNT : 4 --------------------------------------------------------------------------------- NAME : recovery_rollback_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : recovery_commit_op ACCUM_COUNT : 0 --------------------------------------------------------------------------------- NAME : split_index_node ACCUM_COUNT : 2 --------------------------------------------------------------------------------- 16 row selected
성능면에서 다음 항목들의 변화 추이를 확인해봐야 한다.
빈번한 연결/ 해제 반복 (init_handle 증가)
빈번한 prepare 호출 (prepare_op 증가)
개별 operation에 대한 처리량 변화 추이 (insert_op, update_op, delete_op 등의 변화추이)
aging_op 증가는 대량 변경 작업으로 versioning 된 row들이 많아질 때 발생할 수 있다.
aging 작업이 많을 경우 변경 DML 또는 조회 시점마다 aging 작업 즉 참조되지 않는 레코드 공간을 정리하는 작업이 발생하여 성능이 저하될 수 있다.
비정상적인 프로세스 종료 등이 발생한 경우, 다음 항목을 확인해봐야 한다.
recovery_rollback_op (프로세스가 종료된 후 rollback 형태로 복구가 진행된 경우)
recovery_commit_op (프로세스가 이미 commit 된 후 종료하여 이에 대한 리소스만 정리한 경우)
위와 같은 항목들은 프로세스 별로 V$sess_stat에서 동일한 항목으로 조회가 가능하므로 특정 프로세스의 추이를 추적하고자 할 경우 v$sess_stat을 참고한다.
Log Cache 및 Checkpoint 상태
v$log_stat 정보는 디스크 로깅과 관련된 전반적인 상태를 출력한다.
dbmMetaManager(DEMO)> select * from v$log_stat; --------------------------------------------------------------------------------- DISKLOG_ENABLE : 1 ARCHIVE_ENABLE : 0 CURR_FILE_NO : 45 CURR_FILE_OFFSET : 45 LAST_CKPT_FILE_NO : 45 LAST_ARCHIVE_FILE_NO : 45 LAST_CAPTURE_FILE_NO : -1 LOGCACHE_WRITE_IND : 9600016 LOGCACHE_READ_IND : 9600016 FLUSHER_FILE_NO : 46 FLUSHER_FILE_OFFSET : 0 LOG_DIR : /home/lim272/4th_iter/pkg/wal ARCHIVE_DIR : /home/lim272/4th_iter/pkg/arch --------------------------------------------------------------------------------- 1 row selected
체크포인트 운영 시 확인 사항
CURR_FILE_NO
- 트랜잭션이 기록되는 가장 마지막 로그 파일 번호로써 이것이 증가하지 않을 경우 확인해야 한다.
LAST_CKPT_FILE_NO
- dbmCkpt에 의해 체크포인트가 진행된 후 완료된 마지막 로그 파일 번호이다.
LAST_ARCHIVE_FILE_NO
- Archiving 동작이 반영된 마지막 로그 파일 번호이다.
위의 세 값들은 상황에 따라 다를 수 있으나 기본적으로 dbmCkpt, dbmLogFlusher 들의 상태를 의미하므로 트랜잭션이 지속적으로 발생하는데도 이 값들이 변동되지 않을 경우에는 dbmCkpt와 dbmLogFlusher 프로세스들의 동작 상태를 체크해야 한다. 만일 프로세스 문제가 아니라면 디스크 공간 부족 등의 HW 적인 원인으로 인해 오류가 발생할 수도 있으므로 HW 부분을 체크해야 한다.
LOG_CACHE MODE 운영 시 확인 사항
LOGCACHE_WRITE_IND
- LOG_CACHE MODE로 설정했을 때 변경되며 트랜잭션이 commit 될 때마다 증가한다.
- 만일 log cache 내에 공간이 부족할 경우 이 값은 증가하지 않고 같은 값으로 유지된다.
LOGCACHE_READ_IND
- dbmLogFlusher가 LogCache의 내용을 디스크로 기록한 후에 증가된다.
- dbmLogFlusher가 정상적으로 동작하지 않으면 위 두 개 항목의 값들도 모두 변경되지 않으므로 이를 확인해야 한다.