Altibase 모니터링 쿼리 가이드#
개요#
이 문서는 Altibase를 모니터링할 때 알아야 할 메타 테이블과 성능 뷰를 소개하고, 모니터링 요소별 쿼리 예시를 제시한다. 먼저 모니터링의 분류와 데이터 딕셔너리를 설명하고, 이어서 주요 메타 테이블과 성능 뷰의 관계를 ERD로 보여 준다. 마지막으로 세션, 쿼리, 트랜잭션, 테이블스페이스, 객체, 이중화 등 모니터링 요소별 쿼리를 제공한다.
이 문서는 이름만으로 의미를 알 수 있는 칼럼과 앞에서 이미 설명한 칼럼의 설명은 생략한다. 메타 테이블과 성능 뷰의 자세한 설명은 Altibase 매뉴얼의 General Reference를 함께 참고한다.
이 문서는 Altibase 4 이상 버전을 기준으로 한다.
Info
이 문서는 정보 제공을 목적으로 하며, 사전에 예고 없이 변경될 수 있습니다. 이 문서는 오류가 있을 수 있으며, 상업적 또는 특정 목적에 부합하는 명시적, 묵시적인 책임이 일절 없습니다.
이 문서에 포함된 Altibase 제품의 특징이나 기능의 개발, 발표 등의 시기는 Altibase 재량입니다.
Altibase는 이 문서에 대하여 관련된 특허권, 상표권, 저작권 또는 기타 지적 재산권을 보유할 수 있습니다.
모니터링 분류#
DBMS 모니터링은 크게 세 가지로 나눌 수 있다.
- 내부 모니터링: 데이터 딕셔너리를 조회하는 쿼리로 DBMS 내부를 모니터링한다.
- 외부 모니터링: OS 명령어로 DBMS 외부에서 모니터링한다.
- 트레이스 로그 모니터링: DBMS가 기록하는 각종 트레이스 로그를 모니터링한다.
이 문서는 이 가운데 내부 모니터링에 필요한 쿼리를 다룬다.
데이터 딕셔너리#
데이터 딕셔너리는 데이터베이스에 관한 정보를 요약해 저장하며, 사용자는 이를 통해 DBMS를 효율적으로 사용할 수 있다. 데이터 딕셔너리에는 메타 테이블과 성능 뷰가 있다.
메타 테이블(meta table)은 데이터베이스 객체를 관리하기 위해 데이터베이스를 생성할 때 자동으로 만드는 테이블이다. 시스템 관리자인 SYSTEM_ 사용자가 메타 테이블의 소유자이며, 일반 사용자는 조회만 할 수 있다.
성능 뷰(performance view)는 조회하는 시점의 Altibase 내부 상태 정보를 뷰 형태로 보여 주므로, 사용자는 성능 뷰로 최신 상태를 확인할 수 있다. 성능 뷰도 조회만 할 수 있으며, 이름은 V$로 시작한다.
메타 테이블과 성능 뷰의 관계#
내부 모니터링을 하려면 먼저 데이터 딕셔너리인 메타 테이블과 성능 뷰를 이해해야 한다. 이 문서는 사용자가 쉽게 이해하고 조인 쿼리를 작성할 수 있도록 메타 테이블과 성능 뷰의 관계를 ERD(Entity-Relationship Diagram)로 나타낸다.
ERD 표기#
성능 뷰에는 기반 테이블이 없지만, 이 문서의 ERD는 아래와 같이 성능 뷰도 테이블로 그리고 조인할 때 참고할 주요 키를 FK 형태로 나타낸다. 메타 테이블과 구분하기 위해 메타 테이블은 연한 남색 배경으로, 성능 뷰는 흰색 배경으로 그린다.

위 ERD에서 메타 테이블의 ID 칼럼과 성능 뷰의 META_ID 칼럼처럼 같은 속성의 칼럼이 메타 테이블과 성능 뷰에서 서로 다른 이름을 가질 수 있다. 이런 칼럼은 같은 색으로 칠해 같은 속성임을 나타낸다.
버전에 따른 차이#
메타 테이블과 성능 뷰의 칼럼 이름과 구성은 Altibase 버전에 따라 다르며, 버전에 따라 없는 메타 테이블과 성능 뷰도 있다.
용어#
세션(session)은 데이터베이스에 접속한 사용자의 접속 단위이다. 한 사용자는 동시에 여러 세션을 가질 수 있다.
Statement는 트랜잭션에서 수행하는 SQL 문 하나하나를 가리킨다. SQL 문, 질의, 쿼리는 문맥에 따라 같은 뜻으로 쓰이며, 이 문서는 '쿼리'로 통일한다.
메모리 데이터베이스 GC(garbage collector)는 트랜잭션이 커밋한 뒤 MVCC(Multi-Version Concurrency Control) 기법으로 유지하던 변경 전 레코드를 삭제하는 스레드로, 줄여서 GC 또는 Ager라고 부른다.
TIMED_STATISTICS 프로퍼티#
V$STATEMENT의 쿼리 수행 시간 칼럼과 통계 정보 관련 성능 뷰의 통계 정보는 TIMED_STATISTICS 프로퍼티를 활성화해야 확인할 수 있다. TIMED_STATISTICS의 기본값은 0으로 비활성화 상태이므로 반드시 설정을 확인한다. 확인과 활성화 방법은 TIMED_STATISTICS 활성화 방법을 참고한다.
세션과 트랜잭션 관련#
사용자는 메타 테이블과 성능 뷰로 세션, 쿼리, 트랜잭션, 잠금(lock), 서비스 스레드, 메모리 데이터베이스 GC의 상태를 실시간으로 확인할 수 있다. 아래 그림은 조인할 때 참고할 주요 키 칼럼만 표기한 관계도이다.
V$MEMGC는 메모리 데이터베이스 GC에 관한 성능 뷰로, 다른 메타 테이블이나 성능 뷰와 직접적인 관계는 없지만 V$TRANSACTION의 특정 칼럼과 함께 활용한다. 이중화로 발생한 트랜잭션도 V$TRANSACTION, V$LOCK, V$LOCK_WAIT에 나타나지만, 이중화 트랜잭션에는 세션 번호와 쿼리 번호가 없으므로 이중화 관련에서 따로 설명한다.

주요 메타 테이블#
| 메타 테이블 | 설명 |
|---|---|
| SYS_USERS_ | 데이터베이스 사용자 정보를 저장한다. 사용자 이름(USER_NAME) 같은 정보를 확인할 수 있어 가장 기본으로 활용한다. |
| SYS_TABLES_ | 테이블(큐 테이블 포함)뿐 아니라 시퀀스와 뷰의 정보도 함께 저장한다. 객체 이름(TABLE_NAME) 같은 정보를 확인할 수 있어 SYS_USERS_와 함께 기본으로 활용한다. |
주요 성능 뷰#
| 성능 뷰 | 설명 |
|---|---|
| V$SESSION | 현재 접속한 사용자의 세션 정보를 보여 준다. |
| V$STATEMENT, V$SQLTEXT, V$PLANTEXT |
V$STATEMENT는 세션에서 수행한 쿼리의 정보와 쿼리 수준의 통계 정보를 보여 주며, 쿼리의 수행 시간과 수행 빈도를 측정할 수 있다. V$STATEMENT는 세션별로 가장 마지막에 직접 수행(direct execution)한 쿼리 하나와 준비(Prepare)한 여러 쿼리만 유지하며, 세션이 종료되면 해당 정보도 사라진다. 쿼리 텍스트는 최대 16KB까지 확인할 수 있다. 쿼리 텍스트가 16KB를 넘으면 전체 텍스트를 보여 주는 V$SQLTEXT를, 쿼리의 실행 계획을 확인하려면 V$PLANTEXT를 활용한다. |
| V$SERVICE_THREAD | 서비스 스레드의 상태를 보여 준다. V$SESSION, V$STATEMENT와 조인해 관련 세션과 쿼리를 확인할 수 있으며, 뷰 자체로도 의미가 있어 단독으로 모니터링하기도 한다. |
| V$TRANSACTION, V$MEMGC |
V$TRANSACTION은 현재 수행 중인 트랜잭션의 정보를 보여 주며, 잠금을 모니터링할 때 기본으로 사용한다. 메모리 데이터베이스 GC 정보를 보여 주는 V$MEMGC와 함께 사용하면 세션, 쿼리와 연계된 MVCC 상태를 확인할 수 있다. |
| V$LOCK, V$LOCK_WAIT | V$LOCK은 트랜잭션 수행 중에 발생한 잠금 정보를 보여 주며, 잠금의 선후 관계를 보여 주는 V$LOCK_WAIT과 함께 활용한다. |
| V$LOCK_STATEMENT | 현재 잠금을 획득한 트랜잭션에서 가장 마지막에 수행한 쿼리를 보여 준다. 잠금이 발생했을 때 관련 세션과 쿼리를 빠르게 확인하는 데 주로 활용한다. |
테이블스페이스와 테이블 관련#
Altibase는 하이브리드 DBMS이므로 테이블스페이스와 테이블 정보를 메모리와 디스크로 나누어 확인한다(아래 그림의 TBS, TABLE 박스 참고). 세그먼트는 V$SEGMENT와 관계(보라색)된 각 성능 뷰로 자원 사용 현황을 자세히 확인할 수 있다.
메모리 인덱스의 크기는 메타 테이블이나 성능 뷰로 직접 확인할 수 없으므로, 테이블 전체 레코드 수에 레코드 하나당 메모리 인덱스 크기인 16바이트를 곱해 추정한다. 디스크 인덱스는 V$INDEX로 세그먼트를 찾아 실시간으로 크기를 측정할 수 있다.
아래 그림은 테이블스페이스, 테이블, 칼럼, 인덱스, 제약조건을 조인할 때 참고할 주요 키 칼럼만 표기한 관계도이다.

SYS_TABLES_를 다른 메타 테이블과 조인할 때는 TABLE_ID 칼럼을, 성능 뷰와 조인할 때는 대체 키인 TABLE_OID 칼럼(파란색)을 조인 칼럼으로 사용한다. 그림에는 표기하지 않았지만, SYS_USERS_와 SYS_TABLES_를 제외한 모든 메타 테이블에는 USER_ID와 TABLE_ID 칼럼이 모두 있다. 성능 뷰 V$SEGMENT와 V$INDEX에도 테이블별로 합산할 수 있도록 TABLE_OID 칼럼이 있다.
주요 메타 테이블#
| 메타 테이블 | 설명 |
|---|---|
| SYS_COLUMNS_ | 테이블의 칼럼 정보를 저장한다. 칼럼 이름(COLUMN_NAME), 데이터 타입(DATA_TYPE), 칼럼 순서(COLUMN_ORDER) 같은 정보를 확인할 수 있다. |
| SYS_CONSTRAINTS_ | 테이블의 제약조건 정보를 저장한다. 제약조건 유형(CONSTRAINT_TYPE)을 확인할 수 있으며, PK, FK, UK처럼 인덱스를 생성하는 제약조건은 관련 인덱스 번호(INDEX_ID)도 확인할 수 있다. FK는 참조 테이블(REFERENCED_TABLE_ID)도 확인할 수 있다. |
| SYS_CONSTRAINT_COLUMNS_ | 제약조건 대상 칼럼의 칼럼 번호(COLUMN_ID)를 제약조건 번호(CONSTRAINT_ID)와 함께 저장한다. |
| SYS_INDICES_ | 인덱스 정보를 저장한다. 인덱스 이름(INDEX_NAME), 테이블스페이스 번호(TBS_ID), 인덱스 유형(INDEX_TYPE), 구성 칼럼 개수(COLUMN_CNT) 같은 정보를 확인할 수 있다. |
주요 성능 뷰#
| 성능 뷰 | 설명 |
|---|---|
| V$TABLESPACES | 테이블스페이스 정보를 보여 주며, 테이블스페이스를 모니터링할 때 기본으로 활용한다. |
| V$MEM_TABLESPACES | 메모리 테이블스페이스의 정보를 보여 준다. 메모리 데이터베이스 운영에 실제로 사용하는 물리 메모리 크기를 구할 수 있다. |
| V$DATAFILES | 디스크 테이블스페이스를 구성하는 데이터 파일의 정보를 보여 주며, 데이터 파일의 경로, 상태, 크기를 확인할 수 있다. |
| V$SEGMENT | 디스크 테이블의 세그먼트 정보를 보여 준다. 디스크 테이블, 디스크 인덱스, 언두 테이블스페이스, 임시 테이블스페이스 같은 디스크 데이터베이스 객체의 정확한 크기를 구할 수 있다. |
| V$MEMTBL_INFO | 메모리 테이블의 정보를 보여 주며, 메모리 테이블별 순수 데이터 크기와 합계를 구할 수 있다. |
| V$DISKTBL_INFO | 디스크 테이블의 정보를 보여 준다. 세그먼트(SEG_PID)를 알 수 있어 디스크 테이블별 순수 데이터 크기와 합계를 구할 수 있다. |
| V$INDEX | 인덱스의 간략한 정보를 보여 준다. 디스크 인덱스는 세그먼트(INDEX_SEG_PID)를 알 수 있어 크기를 구할 수 있다. |
통계 정보 관련#
사용자는 성능 뷰로 DBMS 수준, 세션 수준, 쿼리 수준의 대기 이벤트(wait event) 통계, 시스템 통계와 세션 통계, DBMS 수준의 디스크 테이블스페이스 데이터 파일 I/O 통계, 메모리 사용량, 버퍼 풀 통계 같은 다양한 통계 정보를 확인할 수 있다.
통계 정보를 유지하는 기준은 수준에 따라 다르다. DBMS 수준의 통계 정보는 구동한 뒤부터 누적하고, 종료하면 초기화한다. 따라서 특정 기간의 값을 알려면 모든 칼럼 값에 대해 현재 값에서 측정 시작 시점의 값을 빼야 한다. 세션 수준의 통계 정보는 해당 세션이 접속해 있는 동안 유지한다. 쿼리 수준의 통계 정보는 앞에서 설명한 V$STATEMENT가 제공하므로 이 절에서는 생략한다.
대기 이벤트 통계, 세션 통계, 데이터 파일 I/O 통계를 특정 세션이나 데이터 파일 기준으로 확인하려면 다른 성능 뷰와 조인한다. 아래 그림은 이때 참고할 주요 키 칼럼만 표기한 관계도이다.

대기 이벤트 관련#
대기 이벤트는 세션이나 Altibase 서버의 내부 스레드가 작업 중에 자원을 얻으려고 기다리는 상황이다. 예를 들어 서비스 스레드가 버퍼 풀에 적재된 페이지에 접근하려고 페이지 래치 획득을 기다리거나, 로그를 기록하려고 로그 버퍼의 래치 획득을 기다리는 상황이 있다. 대기 이벤트는 상위 개념인 대기 클래스(wait class)로 묶어 8가지로 분류한다.
| 성능 뷰 | 설명 |
|---|---|
| V$SYSTEM_WAIT_CLASS | 세션과 내부 스레드의 대기 이벤트 통계를 대기 클래스별로 보여 준다. 구동한 뒤부터 누적하고, 종료하면 초기화한다. |
| V$SYSTEM_EVENT | 세션과 내부 스레드의 대기 이벤트 통계를 대기 이벤트별로 보여 준다. 구동한 뒤부터 누적하고, 종료하면 초기화한다. |
| V$SESSION_EVENT | 세션의 대기 이벤트 통계만 보여 준다. 세션이 종료되면 관련 통계도 사라진다. |
| V$SESSION_WAIT | 조회 시점에 활성 상태인 세션의 대기 이벤트 통계만 보여 준다. 세션이 유휴(idle) 상태가 되거나 종료되면 관련 통계도 사라진다. |
시스템 통계와 세션 통계 관련#
시스템 통계와 세션 통계는 쿼리 수행, 로그 파일 쓰기처럼 세션이나 내부 스레드가 수행한 작업을 통계 항목별로 누적한 값이다.
| 성능 뷰 | 설명 |
|---|---|
| V$SYSSTAT | 세션과 내부 스레드의 작업 통계를 통계 항목별로 보여 준다. 구동한 뒤부터 누적하고, 종료하면 초기화한다. |
| V$SESSTAT | 세션의 작업 통계만 보여 준다. 세션이 종료되면 관련 통계도 사라진다. |
데이터 파일 I/O 관련#
V$FILESTAT는 디스크 테이블스페이스의 데이터 파일별 I/O 통계를 보여 준다.
메모리 관련#
V$MEMSTAT은 Altibase가 현재 사용하는 메모리 양을 모듈별로 보여 준다. Altibase 프로세스의 메모리 사용량이 비정상적일 때 주요 참고 지표가 된다. 모듈의 최고 메모리 사용량을 뜻하는 MAX_TOTAL_SIZE 칼럼은 구동한 뒤부터 유지하고, 종료하면 초기화한다.
버퍼 풀 관련#
V$BUFFPOOL_STAT은 쿼리 수행 시 디스크에서 페이지를 읽지 않고 버퍼 풀에 있는 페이지를 재사용한 비율인 히트율(hit ratio) 같은 버퍼 풀 통계를 실시간으로 보여 준다.
로그 파일 관련#
V$LFG는 로그 파일 관련 통계를 보여 준다. 새 로그 파일을 기다린 횟수를 뜻하는 LF_PREPARE_WAIT_COUNT 칼럼이 주요 모니터링 대상이다.
이중화 관련#
이중화 트랜잭션에는 세션 번호와 쿼리 번호가 없으므로, V$REPSENDER_TRANSTBL과 V$REPRECEIVER_TRANSTBL로 원격 서버에서 대응하는 트랜잭션을 식별한다. 아래 그림은 이중화를 모니터링할 때 참고할 주요 키 칼럼만 표기한 관계도이다.

주요 메타 테이블#
| 메타 테이블 | 설명 |
|---|---|
| SYS_REPLICATIONS_ | 이중화 객체의 정보를 저장한다. 원격 서버가 이중화를 반영한 시점(XSN) 같은 정보를 확인할 수 있다. |
| SYS_REPL_HOSTS_ | 원격 서버의 정보를 저장한다. 원격 서버의 주소(HOST_IP)와 포트 번호(PORT_NO)를 확인할 수 있다. |
| SYS_REPL_ITEMS_ | 이중화 대상 테이블의 정보를 저장한다. 사용자 이름과 테이블 이름도 함께 저장하므로 SYS_USERS_, SYS_TABLES_와 조인하지 않아도 된다. |
주요 성능 뷰#
아래 성능 뷰는 모두 해당 Sender 또는 Receiver가 구동 중일 때만 조회할 수 있다.
| 성능 뷰 | 설명 |
|---|---|
| V$REPSENDER | 이중화 송신 스레드인 Sender의 상태를 보여 준다. |
| V$REPGAP | 최신 로그 일련번호와 Sender가 전송한 로그 일련번호의 간격인 이중화 갭을 보여 준다. 이 값은 지역 서버와 원격 서버 간 동기화 정도를 뜻하므로 이중화를 모니터링할 때 반드시 활용한다. |
| V$REPRECEIVER | 이중화 수신 스레드인 Receiver의 상태를 보여 준다. |
| V$REPSENDER_TRANSTBL | Sender가 수행 중인 이중화 트랜잭션의 정보를 보여 주며, 해당 트랜잭션에 대응하는 원격 서버의 트랜잭션을 알 수 있다. |
| V$REPRECEIVER_TRANSTBL | Receiver가 수행 중인 이중화 트랜잭션의 정보를 보여 주며, 해당 트랜잭션에 대응하는 원격 서버의 트랜잭션을 알 수 있다. 이중화 트랜잭션이 획득한 잠금 때문에 지역 서버의 트랜잭션이 대기할 때 주요 참고 지표가 된다. |
권한과 스키마 객체 관련#
사용자의 테이블스페이스 접근 권한, 시스템/객체 권한, 그리고 PSM(프로시저, 함수, 타입 세트)과 뷰 같은 스키마 객체 정보는 메타 테이블로 확인한다. 아래 그림은 이 정보를 조인할 때 참고할 주요 키 칼럼만 표기한 관계도이다.

SYS_GRANT_OBJECT_의 객체 번호인 OBJ_ID 칼럼(녹색)에 대응하는 칼럼의 이름은 객체에 따라 다르므로 주의한다. 그림에서는 TABLE_ID(붉은색), VIEW_ID(붉은색), PROC_OID(보라색) 칼럼이 이에 해당한다.
대부분의 데이터베이스 객체는 대응하는 메타 테이블을 따로 갖지만, 뷰는 테이블과 함께 관리하므로 뷰 이름 같은 구체적인 정보는 SYS_TABLES_에서 확인해야 한다. SYS_VIEWS_에는 뷰의 컴파일 상태만 저장되며, SYS_VIEWS_의 VIEW_ID는 SYS_TABLES_의 TABLE_ID와 같다.
주요 메타 테이블#
| 메타 테이블 | 설명 |
|---|---|
| SYS_TBS_USERS_ | 사용자가 접근할 수 있는 테이블스페이스 목록을 저장한다. |
| SYS_PRIVILEGES_ | 시스템 권한과 객체 권한의 권한 번호(PRIV_ID)와 권한 이름(PRIV_NAME)을 저장한다. |
| SYS_GRANT_SYSTEM_ | 사용자가 부여받은 시스템 권한의 권한 번호(PRIV_ID)를 저장한다. |
| SYS_GRANT_OBJECT_ | 사용자가 부여받은 객체 권한의 권한 번호(PRIV_ID)와 객체 정보를 저장한다. 객체 번호(OBJ_ID)로 해당 객체의 정보를 확인할 수 있다. |
| SYS_VIEWS_, SYS_VIEW_PARSE_ | SYS_VIEWS_는 뷰의 컴파일 상태만 저장한다. 뷰의 생성 구문은 SYS_VIEW_PARSE_에서 확인할 수 있다. |
| SYS_PROCEDURES_, SYS_PROC_PARSE_ |
SYS_PROCEDURES_는 PSM(프로시저, 함수, 타입 세트)의 정보를 저장한다. 각 PSM의 생성 구문은 SYS_PROC_PARSE_에서 확인할 수 있다. |
모니터링 요소와 모니터링 쿼리#
이 장은 세션, 쿼리, 트랜잭션, 테이블스페이스, 객체, 이중화 등 모니터링 요소별로 상태를 확인하는 쿼리와 주요 칼럼의 의미를 제시한다. 쿼리의 SELECT 절, WHERE 절, LIMIT 절은 모니터링 목적에 맞게 바꾸어 사용한다.
TIMED_STATISTICS 활성화 방법#
쿼리 수행 시간 정보를 확인하려면 TIMED_STATISTICS 프로퍼티를 활성화(1)해야 한다. 기본값은 0으로 비활성화 상태이다. 현재 설정은 다음 쿼리로 확인한다.
SELECT NAME, VALUE1 FROM V$PROPERTY WHERE NAME = 'TIMED_STATISTICS';
다음 SQL 문으로 TIMED_STATISTICS를 활성화하면, 활성화한 뒤에 수행한 쿼리의 시간 정보를 확인할 수 있다.
ALTER SYSTEM SET TIMED_STATISTICS=1;
TIMED_STATISTICS는 Altibase 5부터 제공하는 프로퍼티이다.
세션#
세션 상태를 확인하는 쿼리를 소개한다. 특정 세션만 모니터링하려면 WHERE 절에 V$SESSION의 ID 칼럼 조건을 추가한다.
[SS01] 전체 세션 개수#
Altibase에 접속한 세션 수를 보여 준다.
SELECT COUNT(*) TOTAL_SESSION_CNT FROM V$SESSION ;
[SS02] 세션 정보#
세션의 클라이언트 정보, 로그인 시각 등 세션 관련 정보를 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있으며, CLIENT_APP_INFO 칼럼을 삭제하거나 주석 처리하면 Altibase 4에서도 사용할 수 있다.
SELECT A.ID SESSION_ID
, A.DB_USERNAME USER_NAME
, REPLACE2(REPLACE2(A.COMM_NAME, 'SOCKET-', NULL), '-SERVER', NULL) CLIENT_IP
, A.CLIENT_APP_INFO -- Altibase 4에서는 삭제한다.
, A.CLIENT_PID
, A.SESSION_STATE
, DECODE(A.AUTOCOMMIT_FLAG, 1, 'ON', 'OFF') AUTOCOMMIT
, DECODE(A.LOGIN_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + A.LOGIN_TIME / (24*60*60), 'YY/MM/DD HH:MI:SS')) LOGIN_TIME
, DECODE(A.IDLE_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + A.IDLE_START_TIME / (24*60*60), 'YY/MM/DD HH:MI:SS')) IDLE_TIME
, NVL(LTRIM(B.QUERY), 'NONE') CURRENT_QUERY
FROM V$SESSION A LEFT OUTER JOIN V$STATEMENT B ON A.CURRENT_STMT_ID = B.ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| CLIENT_IP | 세션과 관련된 클라이언트 응용 프로그램의 IP 주소이다. |
| CLIENT_APP_INFO | 세션과 관련된 클라이언트 응용 프로그램의 이름이다. Altibase 5부터 제공한다. |
| CLIENT_PID | 세션과 관련된 클라이언트 응용 프로그램의 프로세스 ID이다. 클라이언트 응용 프로그램이 실행되는 OS에서 해당 프로세스를 식별할 수 있다. |
| SESSION_STATE | 세션의 상태를 나타내는 문자열이다. INIT, AUTH, SERVICE READY, SERVICE, END, ROLLBACK, UNKNOWN 7가지 상태가 있다. |
| IDLE_TIME | 세션이 아무 작업도 하지 않기 시작한 시각으로, IDLE_TIMEOUT의 기준이 된다. 원래 값의 단위는 유닉스 시간(unix time)이다. |
| CURRENT_QUERY | 세션에서 가장 마지막으로 수행했거나 현재 수행 중인 쿼리이다. |
[SS03] SYSDBA 권한으로 접속 중인 세션 정보#
SYSDBA 권한으로 접속한 세션의 정보를 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있으며, CLIENT_APP_INFO 칼럼을 삭제하거나 주석 처리하면 Altibase 4에서도 사용할 수 있다. SELECT 절의 칼럼은 [SS02] 세션 정보와 같으므로 해당 칼럼 설명을 참고한다.
SELECT A.ID SESSION_ID
, A.DB_USERNAME USER_NAME
, REPLACE2(REPLACE2(A.COMM_NAME, 'SOCKET-', NULL), '-SERVER', NULL) CLIENT_IP
, A.CLIENT_APP_INFO -- Altibase 4에서는 삭제한다.
, A.CLIENT_PID
, A.SESSION_STATE
, DECODE(A.AUTOCOMMIT_FLAG, 1, 'ON', 'OFF') AUTOCOMMIT
, DECODE(A.LOGIN_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + A.LOGIN_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LOGIN_TIME
, DECODE(A.IDLE_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + A.IDLE_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) IDLE_TIME
, NVL(LTRIM(B.QUERY), 'NONE') CURRENT_QUERY
FROM V$SESSION A LEFT OUTER JOIN V$STATEMENT B ON A.CURRENT_STMT_ID = B.ID
WHERE A.SYSDBA_FLAG = 1
;
쿼리#
쿼리 상태를 확인하는 쿼리를 소개한다. 특정 세션의 쿼리만 모니터링하려면 WHERE 절에 V$STATEMENT의 SESSION_ID 칼럼 조건을 추가한다.
[ST01] 전체 쿼리 개수#
SELECT COUNT(*) AS TOTAL_STMT_CNT FROM V$STATEMENT ;
[ST02] 쿼리 정보#
SELECT SESSION_ID
, ID STMT_ID
, TX_ID
, ROUND((PARSE_TIME+VALIDATE_TIME+OPTIMIZE_TIME)/1000000, 1) PREPARE_TIME
, ROUND(FETCH_TIME/1000000, 1) FETCH_TIME
, ROUND(EXECUTE_TIME/1000000, 1) EXECUTE_TIME
, ROUND(TOTAL_TIME/1000000, 1) TOTAL_TIME
, EXECUTE_FLAG
, DECODE(LAST_QUERY_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + LAST_QUERY_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LAST_START_TIME
, NVL(LTRIM(QUERY), 'NONE') QUERY
FROM V$STATEMENT
ORDER BY EXECUTE_TIME DESC
;
주요 칼럼의 의미는 다음과 같다. PREPARE_TIME, EXECUTE_TIME, FETCH_TIME, TOTAL_TIME 값은 TIMED_STATISTICS를 활성화해야 확인할 수 있으며, TIMED_STATISTICS를 제공하지 않는 Altibase 4에서는 의미가 없다.
| 칼럼 | 설명 |
|---|---|
| STMT_ID | 쿼리의 ID이다. |
| TX_ID | 해당 쿼리를 수행한 트랜잭션의 ID이다. |
| PREPARE_TIME | 준비(Prepare: 구문 분석, 검증, 최적화)에 걸린 시간으로, 단위는 초이다. 쿼리를 수행할 때마다 값이 바뀐다. |
| EXECUTE_TIME | 준비를 마친 뒤 실행에 걸린 시간으로, 단위는 초이다. 쿼리를 수행할 때마다 값이 바뀌며, QUERY_TIMEOUT의 기준이 된다. |
| FETCH_TIME | 클라이언트가 쿼리 결과를 가져가는(fetch) 데 걸린 시간으로, 단위는 초이다. 결과 크기에 따라 쿼리 하나가 결과를 여러 번 가져갈 수 있으며, 그때마다 값이 바뀐다. FETCH_TIMEOUT의 기준이 된다. |
| TOTAL_TIME | 쿼리 하나를 수행하는 데 걸린 시간의 합계로, 준비, 실행, fetch 시간을 모두 포함한다. 단위는 초이며, 쿼리를 수행할 때마다 값이 바뀐다. |
| EXECUTE_FLAG | 0이면 준비만 마친 상태이고, 1이면 실행 중인 상태이다. |
| LAST_START_TIME | 가장 마지막으로 쿼리를 수행한 시각이다. 원래 값의 단위는 유닉스 시간(unix time)이다. |
[ST03] 현재 수행 중인 쿼리 개수#
SELECT COUNT(*) AS ACTIVE_STMT_CNT
FROM V$STATEMENT
WHERE EXECUTE_FLAG = 1
;
[ST04] 현재 수행 중인 쿼리 정보#
칼럼 설명은 [ST02] 쿼리 정보를 참고한다.
SELECT SESSION_ID
, ID STMT_ID
, TX_ID
, ROUND((PARSE_TIME+VALIDATE_TIME+OPTIMIZE_TIME)/1000000, 1) PREPARE_TIME
, ROUND(FETCH_TIME/1000000, 1) FETCH_TIME
, ROUND(EXECUTE_TIME/1000000, 1) EXECUTE_TIME
, ROUND(TOTAL_TIME/1000000, 1) TOTAL_TIME
, DECODE(LAST_QUERY_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + LAST_QUERY_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LAST_START_TIME
, NVL(LTRIM(QUERY), 'NONE') QUERY
FROM V$STATEMENT
WHERE EXECUTE_FLAG = 1
ORDER BY EXECUTE_TIME DESC
;
[ST05] 장시간 수행 쿼리 정보#
600초 이상 수행 중인 쿼리의 정보를 보여 준다. 칼럼 설명은 [ST02] 쿼리 정보를 참고한다.
SELECT SESSION_ID
, ID STMT_ID
, TX_ID
, ROUND((PARSE_TIME+VALIDATE_TIME+OPTIMIZE_TIME)/1000000, 1) PREPARE_TIME
, ROUND(FETCH_TIME/1000000, 1) FETCH_TIME
, ROUND(EXECUTE_TIME/1000000, 1) EXECUTE_TIME
, ROUND(TOTAL_TIME/1000000, 1) TOTAL_TIME
, DECODE(LAST_QUERY_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + LAST_QUERY_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LAST_START_TIME
, NVL(LTRIM(QUERY), 'NONE') QUERY
FROM V$STATEMENT
WHERE EXECUTE_FLAG = 1
AND EXECUTE_TIME/1000000 > 600 -- 수행 시간 조건(초)을 바꾸려면 이 값을 변경한다.
ORDER BY EXECUTE_TIME DESC
;
[ST06] 장시간 수행되는 DML 트랜잭션의 마지막 쿼리 정보#
3600초 이상 수행 중인 변경 트랜잭션에서 마지막으로 수행한 쿼리의 정보를 보여 준다. SS.CLIENT_APP_INFO 칼럼은 Altibase 5부터 제공하므로 Altibase 4에서는 SELECT 절에서 이 칼럼을 삭제하거나 주석 처리한다.
SELECT ST.SESSION_ID
, SS.COMM_NAME CLIENT_IP
, SS.CLIENT_PID
, SS.CLIENT_APP_INFO
, (BASE_TIME - TR.FIRST_UPDATE_TIME) AS UTRANS_TIME
, ROUND(EXECUTE_TIME/1000000, 1) EXECUTE_TIME
, ROUND(TOTAL_TIME/1000000, 1) TOTAL_TIME
, DECODE(LAST_QUERY_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + LAST_QUERY_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LAST_START_TIME
, NVL(LTRIM(ST.QUERY), 'NONE') QUERY
FROM V$TRANSACTION TR
, V$STATEMENT ST
, V$SESSIONMGR
, V$SESSION SS
WHERE TR.ID = ST.TX_ID
AND ST.SESSION_ID = SS.ID
AND TR.FIRST_UPDATE_TIME != 0 -- 0: 읽기 전용 트랜잭션
AND (BASE_TIME - TR.FIRST_UPDATE_TIME) > 3600 -- 수행 시간 조건(초)을 바꾸려면 이 값을 변경한다.
ORDER BY UTRANS_TIME DESC
;
UTRANS_TIME 칼럼의 의미는 다음과 같다. 다른 칼럼은 [ST02] 쿼리 정보를 참고한다.
| 칼럼 | 설명 |
|---|---|
| UTRANS_TIME | 트랜잭션이 처음 변경 연산을 시작한 시점부터 현재까지 경과한 시간으로, 단위는 초이다. 이 값을 계산하는 V$SESSIONMGR의 BASE_TIME과 V$TRANSACTION의 FIRST_UPDATE_TIME은 TIMED_STATISTICS 프로퍼티를 활성화하지 않아도 확인할 수 있다. |
[ST07] 풀 스캔 쿼리 정보#
풀 스캔을 수행한 쿼리의 정보를 보여 준다. S.CLIENT_APP_INFO 칼럼은 Altibase 5부터 제공하므로 Altibase 4에서는 SELECT 절에서 이 칼럼을 삭제하거나 주석 처리한다. 칼럼 설명은 [ST02] 쿼리 정보를 참고한다.
SELECT SESSION_ID
, S.COMM_NAME CLIENT_IP
, S.CLIENT_PID
, S.CLIENT_APP_INFO
, DECODE(LAST_QUERY_START_TIME, 0, '-', TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + LAST_QUERY_START_TIME / (24*60*60), 'MM/DD HH:MI:SS')) LAST_START_TIME
, ROUND((PARSE_TIME+VALIDATE_TIME+OPTIMIZE_TIME)/1000000, 1) PREPARE_TIME
, ROUND(FETCH_TIME/1000000, 1) FETCH_TIME
, ROUND(EXECUTE_TIME/1000000, 1) EXECUTE_TIME
, ROUND(TOTAL_TIME/1000000, 1) TOTAL_TIME
, NVL(LTRIM(QUERY), 'NONE') QUERY
FROM V$STATEMENT T
, V$SESSION S
WHERE S.ID = T.SESSION_ID
AND (MEM_CURSOR_FULL_SCAN > 0 OR DISK_CURSOR_FULL_SCAN > 0)
AND UPPER(QUERY) NOT LIKE '%INSERT%'
ORDER BY EXECUTE_TIME DESC
;
[ST08] 풀 스캔 쿼리 수행 횟수 통계#
SELECT COUNT(EXECUTE_SUCCESS) EXECUTE_CNT
, SUBSTR(LTRIM(QUERY), 1, 40) QUERY
FROM V$STATEMENT
WHERE (MEM_CURSOR_FULL_SCAN > 0 OR DISK_CURSOR_FULL_SCAN > 0)
AND UPPER(QUERY) NOT LIKE '%INSERT%'
GROUP BY QUERY
ORDER BY EXECUTE_CNT DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| EXECUTE_CNT | 수행을 성공적으로 마친 쿼리 실행 횟수의 합계이다. |
[ST09] 세션별 쿼리 목록#
SELECT SESSION_ID
, ID STMT_ID
, TX_ID
, SUBSTR(QUERY, 1, 100) QUERY
FROM V$STATEMENT
ORDER BY 1, 2
;
[ST10] 세션당 Statement 생성 수#
SELECT SE.ID SESSION_ID
, COUNT(DISTINCT ST.ID) CURR_STMT_CNT_PER_SESSION
FROM V$SESSION SE
, V$STATEMENT ST
WHERE 1=1
AND SE.ID=ST.SESSION_ID
GROUP BY SE.ID
ORDER BY SE.ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| CURR_STMT_CNT_PER_SESSION | 해당 세션이 관리하는 Statement 개수이다. |
서비스 스레드#
서비스 스레드 정보를 확인하는 쿼리를 소개한다.
[SV01] 서비스 스레드 상태#
버전에 따라 칼럼 이름이 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5 이상#
SELECT RUN_MODE
, STATE
, COUNT(*) CNT
FROM V$SERVICE_THREAD
GROUP BY RUN_MODE, STATE
;
Altibase 4#
SELECT TYPE
, STATE
, COUNT(*) CNT
FROM V$SERVICE_THREAD
GROUP BY TYPE, STATE
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| RUN_MODE / TYPE | 서비스 스레드의 작동 모드로, SHARED 또는 DEDICATED이다. |
| STATE | 서비스 스레드의 상태로, 일반적으로 POLL 또는 EXECUTE이다. NONE은 초기화된 상태, POLL은 이벤트를 기다리는 상태, QUEUE-WAIT은 작업 큐(task queue)를 기다리는 상태, EXECUTE는 쿼리를 수행 중인 상태이다. |
[SV02] 서비스 스레드 경합 확인#
SELECT NAME
, MISS_COUNT
, TRY_COUNT
, ROUND(MISS_COUNT/TRY_COUNT*100, 2) PER
FROM V$MUTEX
WHERE NAME = 'MMT_SERVICE_THREAD_MUTEX'
ORDER BY 4 DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| MISS_COUNT | Statement를 처리하려고 서비스 스레드에 요청했으나 서비스 스레드가 바빠서 실패한 횟수이다. |
| TRY_COUNT | Statement를 처리하려고 서비스 스레드에 요청한 횟수이다. |
| PER | MISS_COUNT/TRY_COUNT*100 값이다. |
트랜잭션과 잠금#
트랜잭션과 잠금 정보를 확인하는 쿼리를 소개한다.
[TL01] 트랜잭션과 잠금 정보#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT TX.ID TX_ID
, WAIT_FOR_TRANS_ID BLOCKED_TX_ID
, DECODE(TX.STATUS,
0, 'BEGIN',
1, 'PRECOMMIT',
2, 'COMMIT_IN_MEMORY',
3, 'COMMIT',
4, 'ABORT',
5, 'BLOCKED',
6, 'END') STATUS
, DECODE(TX.LOG_TYPE, 0, U1.USER_NAME, 'REPLICATION') USER_NAME
, DECODE(TX.LOG_TYPE, 0, TX.SESSION_ID, RT.REP_NAME) SESSION_ID
, DECODE(TX.LOG_TYPE, 0, ST.COMM_NAME, RR.PEER_IP) CLIENT_IP
, DECODE(ST.AUTOCOMMIT_FLAG, 1, 'ON', 'OFF') AUTOCOMMIT
, L.LOCK_DESC
, DECODE(TX.FIRST_UPDATE_TIME,
0, '0',
TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + TX.FIRST_UPDATE_TIME / (60*60*24), 'MM/DD HH:MI:SS')) FIRST_UPDATE_TIME
, U2.USER_NAME||'.'||T.TABLE_NAME TABLE_NAME
, DECODE(TX.LOG_TYPE, 0, SUBSTR(ST.QUERY, 1, 10), 'REMOTE TX_ID '||REMOTE_TID) CURRENT_QUERY
, DECODE(TX.DDL_FLAG, 0, 'NON-DDL', 'DDL') DDL
, DECODE(TX.FIRST_UNDO_NEXT_LSN_FILENO, -1, '-', TX.FIRST_UNDO_NEXT_LSN_FILENO) 'LOGFILE#'
FROM V$TRANSACTION TX
, V$LOCK L
LEFT OUTER JOIN (SELECT ST.*, SS.AUTOCOMMIT_FLAG, SS.DB_USERID, SS.COMM_NAME
FROM V$STATEMENT ST, V$SESSION SS
WHERE SS.ID = ST.SESSION_ID
AND SS.CURRENT_STMT_ID = ST.ID) ST ON L.TRANS_ID = ST.TX_ID
LEFT OUTER JOIN V$REPRECEIVER_TRANSTBL RT ON L.TRANS_ID = RT.LOCAL_TID
LEFT OUTER JOIN V$REPRECEIVER RR ON RT.REP_NAME = RR.REP_NAME
LEFT OUTER JOIN V$LOCK_WAIT LW ON L.TRANS_ID = LW.TRANS_ID
LEFT OUTER JOIN SYSTEM_.SYS_USERS_ U1 ON ST.DB_USERID = U1.USER_ID
, SYSTEM_.SYS_TABLES_ T
LEFT OUTER JOIN SYSTEM_.SYS_USERS_ U2 ON T.USER_ID = U2.USER_ID
WHERE TX.ID = L.TRANS_ID
AND T.TABLE_OID = L.TABLE_OID
AND TX.STATUS != 6
ORDER BY TX.ID, ST.ID, TX.FIRST_UPDATE_TIME DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TX_ID | 트랜잭션의 ID이다. |
| BLOCKED_TX_ID | 잠금 획득 대기를 일으킨 트랜잭션의 ID이다. 없으면 공백이다. |
| STATUS | 트랜잭션 상태를 나타내는 0~6의 숫자를 문자열로 보여 준다. BEGIN(0), PRECOMMIT(1), COMMIT_IN_MEMORY(2), COMMIT(3), ABORT(4), BLOCKED(5), END(6)이 있다. |
| USER_NAME | 트랜잭션을 수행 중인 사용자의 이름이다. 이중화 트랜잭션이면 'REPLICATION'으로 표시한다. |
| SESSION_ID | 트랜잭션을 수행 중인 세션의 ID이다. 이중화 트랜잭션이면 이중화 객체 이름을 표시한다. |
| CLIENT_IP | 세션과 관련된 클라이언트 응용 프로그램의 IP 주소이다. 이중화 트랜잭션이면 원격 서버의 IP 주소이다. |
| FIRST_UPDATE_TIME | 트랜잭션이 처음 변경 연산을 시작한 시각이다. SELECT만 수행하는 트랜잭션은 0이다. |
| LOCK_DESC | 해당 트랜잭션이 설정한 잠금 정보이다. IX_LOCK, IS_LOCK, X_LOCK 등이 있다. |
| TABLE_NAME | 잠금 획득 대상 테이블로, '사용자 이름.테이블 이름' 형식으로 보여 준다. |
| CURRENT_QUERY | 트랜잭션에서 가장 마지막으로 수행했거나 현재 수행 중인 쿼리이다. 이중화 트랜잭션이면 원격 서버의 트랜잭션 ID를 보여 준다. |
| DDL | 트랜잭션의 DDL 여부로, NON-DDL(0) 또는 DDL(1)이다. |
| LOGFILE# | 트랜잭션과 관련된 로그 파일 번호이다. SELECT만 수행하는 트랜잭션은 '-'이다. |
로그 파일#
로그 파일 정보를 확인하는 쿼리를 소개한다.
[LO01] 로그 파일 정보#
SELECT OLDEST_ACTIVE_LOGFILE OLDEST_LOGFILE
, CURRENT_LOGFILE CURRENT_LOGFILE
, CURRENT_LOGFILE-OLDEST_ACTIVE_LOGFILE LOGFILE_GAP
FROM V$ARCHIVE
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| OLDEST_LOGFILE | 가장 오래된 로그 파일의 번호이다. |
| CURRENT_LOGFILE | 현재 사용 중인 온라인 로그 파일의 번호이다. |
| LOGFILE_GAP | 현재 사용 중인 온라인 로그 파일과 가장 오래된 로그 파일 사이의 로그 파일 개수이다. |
[LO02] 로그 파일 준비 대기 누적 횟수#
SELECT LF_PREPARE_WAIT_COUNT FROM V$LFG ;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| LF_PREPARE_WAIT_COUNT | 현재 로그 파일에서 새 로그 파일로 전환하려 할 때 다음 로그 파일이 아직 생성되지 않아 서비스 스레드가 기다린 횟수이다. 이 값이 크면 PREPARE_LOG_FILE_COUNT 프로퍼티 값을 늘린 뒤 Altibase를 재구동해, 로그 파일을 충분히 미리 만들어 두도록 한다. 이 값은 구동한 뒤부터 누적하고, 종료하면 초기화한다. |
메모리 데이터베이스 GC#
메모리 데이터베이스 GC 정보를 확인하는 쿼리를 소개한다.
[GC01] 메모리 데이터베이스 GC 갭#
SELECT GC_NAME
, SCNOFTAIL
, MINMEMSCNINTXS
, ADD_OID_CNT-GC_OID_CNT GC_GAP
FROM V$MEMGC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| GC_NAME | GC의 이름으로, 두 가지가 있다. MEM_LOGICAL_AGER는 인덱스의 변경 전 버전을 삭제하는 GC이고, MEM_DELTHR는 테이블 레코드의 변경 전 버전을 삭제하는 GC이다. |
| SCNOFTAIL | GC가 확인한, 삭제해야 할 변경 전 버전 중 가장 최신 버전의 번호이다. |
| MINMEMSCNINTXS | 가장 오래된 변경 전 버전의 번호이다. |
| GC_GAP | 각 GC가 삭제해야 할 변경 전 버전의 양으로, 값이 클수록 삭제해야 할 변경 전 버전이 많다. SCNOFTAIL이 MINMEMSCNINTXS보다 크면 활성 트랜잭션 때문에 GC가 삭제를 진행하지 못하는 상황이다. 반대로 SCNOFTAIL이 MINMEMSCNINTXS보다 작으면 GC가 삭제를 진행하고 있지만, 변경 트랜잭션이 계속 완료되면서 삭제해야 할 변경 전 버전이 늘어나는 상황이다. |
[GC02] 메모리 데이터베이스 GC가 대기하고 있는 트랜잭션에서 수행 중인 쿼리#
GC가 대기하고 있는 트랜잭션은 Altibase에서 가장 오래된 변경 전 버전을 참조하는 트랜잭션이다. 이런 트랜잭션 때문에 GC가 동작하지 못하고 계속 대기하면 메모리 사용량도 계속 늘어날 수 있으므로, GC 갭이 증가할 때 이 트랜잭션을 확인한다.
아래 쿼리는 GC가 대기하고 있는 트랜잭션을 수행하는 세션에서 수행한 쿼리를 보여 준다. 인덱스 스캔을 하지만 분포도가 좋지 않아 사실상 풀 스캔처럼 동작하면서 순간적으로 CPU를 많이 소모하는 쿼리를 찾을 때도 유용하다. 상황에 따라 한 번 수행해서는 검출되지 않을 수 있으므로 주기적으로 반복해서 수행한다.
Altibase 5 이상#
SELECT ST.SESSION_ID
, ST.TX_ID
, TOTAL_TIME/1000000 'TOTAL(SEC)'
, EXECUTE_TIME/1000000 'EXECUTE(SEC)'
, FETCH_TIME/1000000 'FETCH(SEC)'
, ST.QUERY
FROM V$STATEMENT ST
, V$TRANSACTION TX
WHERE ST.TX_ID = TX.ID
AND TX_ID IN (SELECT ID
FROM V$TRANSACTION
, (SELECT MINMEMSCNINTXS FROM V$MEMGC LIMIT 1) GC
WHERE MEMORY_VIEW_SCN = GC.MINMEMSCNINTXS
OR MIN_MEMORY_LOB_VIEW_SCN = GC.MINMEMSCNINTXS)
AND ST.SESSION_ID != SESSION_ID()
AND TX.SESSION_ID <> SESSION_ID()
ORDER BY 3 DESC
;
Altibase 4#
SELECT SESSION_ID
, TOTAL_TIME
, EXECUTE_TIME
, TX_ID
, QUERY
FROM V$STATEMENT
WHERE TX_ID IN (SELECT ID
FROM V$TRANSACTION
WHERE MEMORY_VIEW_SCN = (SELECT MINMEMSCNINTXS FROM V$MEMGC LIMIT 1))
AND EXECUTE_FLAG = 1
ORDER BY 2 DESC
;
메모리#
Altibase가 OS에서 점유하는 메모리 정보를 확인하는 쿼리를 소개한다.
[MS01] Altibase의 메모리 사용 현황#
Altibase를 구성하는 모듈별 메모리 사용 현황을 보여 준다.
SELECT NAME
, ROUND(ALLOC_SIZE/1024/1024) 'ALLOC(MB)'
, ROUND(MAX_TOTAL_SIZE/1024/1024) 'MAX_TOTAL(MB)'
FROM V$MEMSTAT
ORDER BY 3 DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| NAME | Altibase를 구성하는 모듈의 이름이다. 모듈 목록은 버전에 따라 다를 수 있다. |
| ALLOC(MB) | 해당 모듈이 현재 사용하는 메모리 크기이다. |
| MAX_TOTAL(MB) | 해당 모듈이 사용한 최대 메모리 크기이다. |
주요 모듈은 다음과 같다.
| 모듈 | 용도 |
|---|---|
| Storage_Disk_Ager | 디스크 데이터베이스 GC |
| Storage_Disk_Buffer | 버퍼 풀 관리 |
| Storage_Disk_Collection | Direct Path Insert와 LOB 연산 |
| Storage_Disk_Datafile | 디스크 파일 관리 |
| Storage_Disk_Index | 디스크 인덱스 관리 |
| Storage_Disk_Page | 디스크 페이지 관리 |
| Storage_Disk_Recovery | 디스크 복구 |
| Storage_Memory_Ager | 메모리 데이터베이스 GC |
| Storage_Memory_Collection | 메모리 레코드 관리 |
| Storage_Memory_Interface | 커서 등 인터페이스 관리 |
| Storage_Memory_Locking | 잠금 관리 |
| Storage_Memory_Manager | 메모리 데이터 저장 |
| Storage_Memory_Index | 인덱스 관리 |
| Storage_Memory_Page | 메모리 페이지 관리 |
| Storage_Memory_Recovery | 메모리 복구 |
| Storage_Memory_Utility | 스토리지 관리자 도구 |
| Storage_Memory_Transaction | 트랜잭션 관리 |
| Temp_Memory | 메모리 인덱스 저장 |
| Transaction_Table | 트랜잭션 테이블 관리 |
| Transaction_OID_List | GC의 OID 저장 |
| Transaction_Table_Info | 트랜잭션 테이블 정보 관리 |
[MS02] Altibase의 메모리 사용량 합계#
SELECT ROUND(SUM(ALLOC_SIZE)/1024/1024) 'ALLOC(MB)'
, ROUND(SUM(MAX_TOTAL_SIZE)/1024/1024) 'MAX_TOTAL(MB)'
FROM V$MEMSTAT
;
테이블스페이스#
테이블스페이스 정보를 확인하는 쿼리를 소개한다.
[TS01] 메모리 테이블스페이스 사용량#
메모리 테이블스페이스별 사용량을 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5.5.1 이상#
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((TOTAL/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT ID TBS_ID
, DECODE(TYPE, 0, 'MEM_SYS_DIC', 1, 'MEM_SYS_DATA', 2, 'MEM_USER_DATA', 8, 'VOL_USER_DATA') TBS_TYPE
, NAME TBS_NAME
, DECODE(M.MAXSIZE, 140737488322560, D.MEM_MAX_DB_SIZE , 0 , T.TOTAL_PAGE_COUNT * T.PAGE_SIZE, M.MAXSIZE) MAX
, M.ALLOC_PAGE_COUNT * T.PAGE_SIZE TOTAL
, NVL(M.ALLOC_PAGE_COUNT-M.FREE_PAGE_COUNT, T.TOTAL_PAGE_COUNT)*PAGE_SIZE ALLOC
, NVL(MT.USED, 0) USED
, DECODE(T.STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, DECODE(M.AUTOEXTEND_MODE, 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATABASE D
, V$TABLESPACES T
, (SELECT SPACE_ID
, SPACE_NAME
, ALLOC_PAGE_COUNT
, FREE_PAGE_COUNT
, DECODE(MAX_SIZE, 0, (SELECT VALUE1
FROM V$PROPERTY
WHERE NAME = 'VOLATILE_MAX_DB_SIZE'), MAX_SIZE) AS MAXSIZE
, AUTOEXTEND_MODE
FROM V$VOL_TABLESPACES
UNION ALL
SELECT SPACE_ID
, SPACE_NAME
, ALLOC_PAGE_COUNT
, FREE_PAGE_COUNT
, MAXSIZE
, AUTOEXTEND_MODE
FROM V$MEM_TABLESPACES ) M LEFT OUTER JOIN (SELECT TABLESPACE_ID, SUM((FIXED_USED_MEM + VAR_USED_MEM)) USED
FROM V$MEMTBL_INFO
GROUP BY TABLESPACE_ID ) MT ON M.SPACE_ID = MT.TABLESPACE_ID
WHERE T.ID = M.SPACE_ID)
;
Altibase 5.3.3#
이 쿼리는 휘발성 메모리 테이블스페이스 정보를 보여 주지 않는다.
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((TOTAL/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT ID TBS_ID
, DECODE(TYPE, 0, 'MEM_SYS_DIC', 1, 'MEM_SYS_DATA', 2, 'MEM_USER_DATA', 8, 'VOL_USER_DATA') TBS_TYPE
, NAME TBS_NAME
, DECODE(MAXSIZE, 140737488322560, D.MEM_MAX_DB_SIZE, 0, ALLOCATED_PAGE_COUNT*PAGE_SIZE, MAXSIZE) MAX
, ALLOCATED_PAGE_COUNT * PAGE_SIZE TOTAL
, NVL(M.ALLOC_PAGE_COUNT-M.FREE_PAGE_COUNT, TOTAL_PAGE_COUNT)*PAGE_SIZE ALLOC
, MT.USED USED
, DECODE(STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, DECODE(AUTOEXTEND_MODE, 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATABASE D
, V$TABLESPACES T
, V$MEM_TABLESPACES M
, (SELECT TABLESPACE_ID
, SUM((FIXED_USED_MEM + VAR_USED_MEM)) USED
FROM V$MEMTBL_INFO
GROUP BY TABLESPACE_ID) MT
WHERE T.ID = M.SPACE_ID
AND ID = MT.TABLESPACE_ID )
;
Altibase 4#
Altibase 4는 사용자가 메모리 테이블스페이스를 생성하는 기능을 제공하지 않으므로, SYS_TBS_MEMORY 테이블스페이스 하나만 나온다. 이 쿼리는 Altibase 4.3.9에서 사용한다.
SELECT TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((TOTAL/1024), 0))*100, '999.99') 'USAGE(%)'
FROM (SELECT 'SYS_TBS_MEMORY' TBS_NAME
, MEM_MAX_DB_SIZE MAX
, MEM_ALLOC_PAGE_COUNT * 32 TOTAL
, (MEM_ALLOC_PAGE_COUNT - MEM_FREE_PAGE_COUNT) * 32 ALLOC
, MTBL.USED USED
FROM V$DATABASE DB
, (SELECT SUM(FIXED_USED_MEM+VAR_USED_MEM) AS USED
FROM V$MEMTBL_INFO ) MTBL )
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TBS_ID | 테이블스페이스 고유 번호이다. |
| TBS_TYPE | 메모리 테이블스페이스 유형이다. 0은 데이터베이스 시스템 운영에 필요한 메타 데이터를 저장하는 시스템 메모리 테이블스페이스, 1은 데이터베이스를 생성할 때 기본으로 만들어지는 데이터를 저장하는 시스템 메모리 테이블스페이스, 2는 사용자가 생성한 메모리 테이블스페이스, 8은 사용자가 생성한 휘발성 메모리 테이블스페이스이다. |
| MAX(MB) | 메모리 테이블스페이스에서 사용할 수 있는 최대 메모리 크기이다. 테이블스페이스를 생성할 때 MAXSIZE를 지정하지 않으면 'UNDEFINED'를 출력한다. 테이블스페이스 속성이 AUTOEXTEND OFF이면 TOTAL(MB) 값을 출력한다. |
| TOTAL(MB) | 메모리 테이블스페이스가 지금까지 할당받은 페이지의 합계이다. 즉 할당된 '사용 중인 페이지'와 '빈 페이지'의 합계로, 체크포인트 이미지 파일 크기와 같다. Altibase를 구동하면 메모리에는 '사용 중인 페이지'만 적재되므로, 이 값만큼 물리 메모리를 사용한다고 판단하기는 어렵다. |
| ALLOC(MB) | 메모리 테이블스페이스가 지금까지 할당받은 페이지 중 '빈 페이지'를 제외한 '사용 중인 페이지'의 합계이다. 예를 들어 100MB 크기의 메모리 테이블에 DROP 또는 TRUNCATE를 수행하면 전체 페이지 합계는 그대로지만, 테이블이 페이지를 반납해 '사용 중인 페이지'가 '빈 페이지'가 되므로 이 값은 0에 가까워진다. |
| USED(MB) | 메모리 테이블스페이스의 '사용 중인 페이지' 중 '실제로 데이터가 적재된 페이지'의 합계이다. 예를 들어 ALLOC이 100MB인 메모리 테이블에서 전체 데이터를 DELETE하면 ALLOC은 100MB로 그대로지만 USED는 0에 가까워진다. |
| USAGE(%) | 메모리 테이블스페이스가 지금까지 할당받은 페이지 대비 사용 중인 페이지의 백분율(USED/TOTAL)이다. |
| STATE | 테이블스페이스의 상태이다. 1은 오프라인, 2는 온라인, 3은 백업 중인 오프라인, 4는 백업 중인 온라인, 128은 삭제된(dropped), 1024는 폐기된(discarded), 1028은 백업 중인 폐기된 상태의 테이블스페이스이다. |
| AUTOEXTEND | 메모리 테이블스페이스의 자동 확장 여부로, ON(1) 또는 OFF(2)이다. |
[TS02] 전체 메모리 테이블스페이스 사용량#
SELECT MEM_MAX_DB_SIZE/1024/1024 'MAX(MB)'
, ROUND(MEM_ALLOC_PAGE_COUNT*32/1024, 2) 'TOTAL(MB)'
, TRUNC((MEM_ALLOC_PAGE_COUNT-MEM_FREE_PAGE_COUNT)*32/1024, 2) 'ALLOC(MB)'
, (SELECT ROUND(SUM((FIXED_USED_MEM + VAR_USED_MEM))/(1024*1024), 3)
FROM V$MEMTBL_INFO) 'USED(MB)'
, TRUNC(((MEM_ALLOC_PAGE_COUNT-MEM_FREE_PAGE_COUNT)*32*1024)/MEM_MAX_DB_SIZE, 4)*100 'USAGE(%)'
FROM V$DATABASE
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| MAX(MB) | 전체 메모리 테이블스페이스가 최대로 할당할 수 있는 페이지의 합계로, MEM_MAX_DB_SIZE 프로퍼티로 정한다. |
| TOTAL(MB) | 전체 메모리 테이블스페이스가 지금까지 할당받은 페이지의 합계이다. |
| ALLOC(MB) | 전체 메모리 테이블스페이스가 지금까지 할당받은 페이지 중 '빈 페이지'를 제외한 '사용 중인 페이지'의 합계이다. |
| USED(MB) | 전체 메모리 테이블스페이스의 '사용 중인 페이지' 중 '실제로 데이터가 적재된 페이지'의 합계이다. |
| USAGE(%) | 전체 메모리 테이블스페이스가 최대로 할당할 수 있는 페이지 대비 사용 중인 페이지의 백분율(ALLOC/MAX)이다. |
[TS03] 디스크 테이블스페이스 사용량#
디스크 테이블스페이스별 사용량을 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5.5.1 이상#
다른 버전과 달리 언두 테이블스페이스의 사용량도 확인할 수 있다.
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT T.ID TBS_ID
, DECODE(TYPE, 3, 'DISK_SYS_DATA', 4, 'DISK_USER_DATA', 5, 'DISK_SYS_TEMP', 6, 'DISK_USER_TEMP', 7, 'DISK_SYS_UNDO') TBS_TYPE
, NAME TBS_NAME
, D.MAX * PAGE_SIZE MAX
, TOTAL_PAGE_COUNT * PAGE_SIZE TOTAL
, DECODE(TYPE, 7, U.TOTAL_EXT_CNT * PROP.EXTENT_SIZE, ALLOCATED_PAGE_COUNT * PAGE_SIZE) ALLOC
, DECODE(TYPE, 3, NVL(DS.USED, 0) , 4, NVL(DS.USED, 0) , 7, (U.TX_EXT_CNT+U.USED_EXT_CNT+U.UNSTEALABLE_EXT_CNT) * PROP.EXTENT_SIZE , ALLOCATED_PAGE_COUNT * PAGE_SIZE ) USED
, DECODE(STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, D.AUTOEXTEND
FROM V$TABLESPACES T LEFT OUTER JOIN(SELECT SPACE_ID , SUM(TOTAL_USED_SIZE) USED FROM X$SEGMENT GROUP BY SPACE_ID) DS ON DS.SPACE_ID = T.ID
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND), 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID ) D
, V$DISK_UNDO_USAGE U
, (SELECT VALUE1 EXTENT_SIZE
FROM V$PROPERTY
WHERE NAME = 'SYS_UNDO_TBS_EXTENT_SIZE') PROP
WHERE T.ID = D.SPACEID )
;
Altibase 5.3.3, 5.3.5#
Altibase 5에서는 디스크 테이블 구조가 바뀌어 디스크 테이블스페이스의 실제 사용량(USED)을 구할 수 없고 할당 크기(ALLOC)만 알 수 있었다. 이후 BUG-31372를 반영한 Altibase 5.3.3.33, 5.3.5.15, 5.5.1.0.3부터 실제 사용량(USED)을 확인할 수 있다. 단, 이 버전에서도 언두 테이블스페이스와 임시 테이블스페이스의 실제 사용량은 구할 수 없다.
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT T.ID TBS_ID
, DECODE(TYPE, 3, 'DISK_SYS_DATA', 4, 'DISK_USER_DATA', 5, 'DISK_SYS_TEMP', 6, 'DISK_USER_TEMP', 7, 'DISK_SYS_UNDO') TBS_TYPE
, NAME TBS_NAME
, D.MAX * PAGE_SIZE MAX
, TOTAL_PAGE_COUNT*PAGE_SIZE TOTAL
, DECODE(TYPE, 7, (SELECT (SUM(TOTAL_EXTENT_COUNT*PAGE_COUNT_IN_EXTENT)*PAGE_SIZE) FROM V$UDSEGS)
+ (SELECT (SUM(TOTAL_EXTENT_COUNT*PAGE_COUNT_IN_EXTENT)*PAGE_SIZE) FROM V$TSSEGS) , /* UNDO */
ALLOCATED_PAGE_COUNT*PAGE_SIZE) ALLOC
, DECODE(TYPE, 3, NVL(DS.USED, 0),
4, NVL(DS.USED, 0) /* SYS_TEMP */
, ALLOCATED_PAGE_COUNT*PAGE_SIZE) USED
, DECODE(STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, D.AUTOEXTEND
FROM V$TABLESPACES T LEFT OUTER JOIN (SELECT SPACE_ID , SUM(TOTAL_USED_SIZE) USED FROM X$SEGMENT GROUP BY SPACE_ID ) DS ON DS.SPACE_ID = T.ID
,(SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND), 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID ) D
WHERE T.ID = D.SPACEID)
;
Altibase 5.1.5#
Altibase 5에서는 디스크 테이블 구조가 바뀌어 디스크 테이블스페이스의 실제 사용량(USED)을 구할 수 없고 할당 크기(ALLOC)만 알 수 있다. 언두 테이블스페이스와 임시 테이블스페이스의 실제 사용량도 구할 수 없다.
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR((ROUND((ALLOC/1024/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT T.ID TBS_ID
, DECODE(TYPE, 3, 'DISK_SYS_DATA', 4, 'DISK_USER_DATA', 5, 'DISK_SYS_TEMP', 6, 'DISK_USER_TEMP', 7, 'DISK_SYS_UNDO') TBS_TYPE
, NAME TBS_NAME
, D.MAX * PAGE_SIZE MAX
, TOTAL_PAGE_COUNT * PAGE_SIZE TOTAL
, DECODE(TYPE, 7, (SELECT (SUM(TOTAL_PAGE_COUNT) * PAGE_SIZE) FROM V$UNDO_SEG) + (SELECT (SUM(ALLOC_PAGE_COUNT) * PAGE_SIZE) FROM V$TSS_SEG))
, ALLOCATED_PAGE_COUNT * PAGE_SIZE ALLOC
, DECODE(STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, D.AUTOEXTEND
FROM V$TABLESPACES T
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND), 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
WHERE T.ID = D.SPACEID)
;
Altibase 4#
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT TBS.ID TBS_ID
, DECODE(TYPE, 1, 'DISK_SYS_DATA', 2, 'DISK_USER_DATA', 3, 'DISK_SYS_TEMP', 4, 'DISK_USER_TEMP', 5, 'DISK_SYS_UNDO') TBS_TYPE
, TBS.NAME TBS_NAME
, DAT.MAX * TBS.PAGE_SIZE MAX
, TBS.TOTAL_PAGE_COUNT * TBS.PAGE_SIZE TOTAL
, DECODE(TBS.TYPE, 5, UNDO.ALLOC * TBS.PAGE_SIZE /* UNDO TABLESPACE */
, TBS.ALLOCATED_PAGE_COUNT * TBS.PAGE_SIZE) ALLOC
, DECODE(TBS.TYPE, 3, TBS.ALLOCATED_PAGE_COUNT * TBS.PAGE_SIZE /* TEMP TABLESPACE */
, 5, UNDO.USED * TBS.PAGE_SIZE /* UNDO TABLESPACE */
, DECODE(SEG.USED, '', 0, (SEG.USED * TBS.PAGE_SIZE * TBS.A_EXTENT_PAGE_COUNT))) /* USER TABLESPACE & SYS_TBS_DATA */ USED
, DECODE(TBS.STATE, 1, 'ONLINE', 2, 'BEGIN BACKUP', 3, 'END BACKUP', 'NOT DEFINED') STATE
, DAT.AUTOEXTEND
FROM V$TABLESPACES TBS
LEFT OUTER JOIN (SELECT SPACE_ID , SUM(EXTENT_TOTAL_COUNT) ALLOC , SUM(EXTENT_FULL_COUNT ) USED FROM X$SEGMENT GROUP BY SPACE_ID ) SEG ON TBS.ID = SEG.SPACE_ID
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND), 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID ) DAT
, (SELECT SUM(ALLOCATED_PAGE_COUNT) ALLOC
, SUM(USED_PAGE_COUNT) USED
FROM V$UNDO_TBS ) UNDO
WHERE TBS.ID = DAT.SPACEID )
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| MAX(MB) | 디스크 테이블스페이스가 최대로 할당할 수 있는 페이지의 합계이다. 페이지는 '사용 중인 페이지'와 '빈 페이지'로 나뉜다. |
| TOTAL(MB) | 디스크 테이블스페이스가 지금까지 할당받은 페이지의 합계이다. 즉 할당된 '사용 중인 페이지'와 '빈 페이지'의 합계로, 데이터 파일 크기에 대응한다. |
| ALLOC(MB) | 디스크 테이블스페이스가 지금까지 할당받은 페이지 중 '빈 페이지'를 제외한 '사용 중인 페이지'의 합계이다. 예를 들어 100MB 크기의 디스크 테이블에 DROP 또는 TRUNCATE를 수행하면 전체 페이지 합계는 그대로지만, 테이블이 페이지를 반납해 '사용 중인 페이지'가 '빈 페이지'가 되므로 이 값은 0에 가까워진다. |
| USED(MB) | 디스크 테이블스페이스의 '사용 중인 페이지' 중 '실제로 데이터가 적재된 페이지'의 합계이다. 디스크 테이블스페이스 관리 기법이 바뀌어 Altibase 5.1.5부터 5.3.3까지는 확인할 수 없고, Altibase 5.5부터는 메모리 테이블스페이스처럼 확인할 수 있다. |
| USAGE(%) | 디스크 테이블스페이스가 최대로 할당할 수 있는 페이지 대비 실제로 데이터가 적재된 페이지의 백분율(USED/MAX)이다. |
[TS04] 디스크 언두 테이블스페이스 사용량#
이 쿼리는 Altibase 5.5.1 이상 버전에서 사용할 수 있다.
SELECT T.NAME TBS_NAME
, ROUND(D.MAX * PAGE_SIZE / 1024 /1024, 2) 'MAX(MB)'
, ROUND((TOTAL_PAGE_COUNT * PAGE_SIZE) / 1024 / 1024, 2) 'TOTAL(MB)'
, ROUND((U.TOTAL_EXT_CNT*PROP.EXTENT_SIZE)/1024/1024, 2) 'ALLOC(MB)'
, ROUND(((U.TX_EXT_CNT+U.USED_EXT_CNT+U.UNSTEALABLE_EXT_CNT) * PROP.EXTENT_SIZE)/1024/1024, 2) 'USED(MB)'
, ROUND((((U.TX_EXT_CNT+U.USED_EXT_CNT+U.UNSTEALABLE_EXT_CNT) * PROP.EXTENT_SIZE)/(D.MAX*PAGE_SIZE))*100, 2) 'USAGE(%)'
, DECODE(STATE,1,'OFFLINE',2,'ONLINE',5,'OFFLINE BACKUP',6,'ONLINE BACKUP',128,'DROPPED', 'DISCARDED') STATE
, D.AUTOEXTEND
FROM V$TABLESPACES T
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND),1,'ON','OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
, V$DISK_UNDO_USAGE U
, (SELECT VALUE1 EXTENT_SIZE FROM V$PROPERTY WHERE NAME = 'SYS_UNDO_TBS_EXTENT_SIZE') PROP
WHERE T.ID = D.SPACEID
AND T.ID = 3
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| MAX(MB) | 언두 테이블스페이스에서 사용할 수 있는 최대 크기이다. |
| TOTAL(MB) | 언두 테이블스페이스가 할당받은 전체 크기이다. |
| ALLOC(MB) | 지금까지 할당받은 페이지 중 '빈 페이지'를 제외한 '사용 중인 페이지'의 합계이다. |
| USED(MB) | 언두 테이블스페이스의 사용량으로, 변경 트랜잭션이 사용 중이거나 재사용할 수 없는 익스텐트의 크기이다. |
| USAGE(%) | MAX 대비 USED의 사용률이다. |
| STATE | 테이블스페이스 상태이다. |
[TS05] 트랜잭션별 언두 테이블스페이스 사용량#
이 쿼리는 Altibase 5.5.1 이상 버전에서 사용할 수 있다.
SELECT DECODE(TX.SESSION_ID, -1, 'REP('||REP.REP_NAME||')', TX.SESSION_ID) SESSION_ID
, TX.ID TX_ID
, DECODE(TX.STATUS, 0, 'BEGIN', 1, 'PRECOMMIT', 2, 'COMMIT_IN_MEMORY', 3, 'COMMIT', 4, 'ABORT', 5, 'BLOCKED', 6, 'END') TX_STATUS
, RPAD(DECODE(ST.EXECUTE_FLAG, NULL, 'REP('||REP.REP_NAME||')', 1, 'SQL ING', 0, 'SQL END'), 10) SQL_STATUS
, RPAD(DECODE(TX.LOG_TYPE, 1, 'REP '||REP.PEER_IP||':'||REP.PEER_PORT, S.COMM_NAME||' PID:'||S.CLIENT_PID), 40) CLIENT_IP
, RPAD(DECODE(TX.LOG_TYPE, 1, 'REP('||REP.REP_NAME||')', S.CLIENT_APP_INFO), 15) CLIENT_APP_INFO
, RPAD(DECODE(S.AUTOCOMMIT_FLAG, 1, 'ON', 0, 'OFF', NULL, 'REP('||REP.REP_NAME||')'), 10) AUTOCOMMIT
, RPAD(DECODE(TX.LOG_TYPE, 1, 'REP('||REP.REP_NAME||')', S.UTRANS_TIME_LIMIT), 15) UTRANS_TIMEOUT
, DECODE(ST.LAST_QUERY_START_TIME, NULL, TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + TX.FIRST_UPDATE_TIME / (60*60*24), 'YYYY-MM-DD HH:MI:SS'), TO_CHAR(TO_DATE('1970010109', 'YYYYMMDDHH') + ST.LAST_QUERY_START_TIME / (60*60*24), 'YYYY-MM-DD HH:MI:SS')) LAST_QUERY_START_TIME
, ((((TSS.TOTAL_EXTENT_COUNT+TSS.TOTAL_EXTDIR_COUNT)*TSS.PAGE_COUNT_IN_EXTENT)+((UDS.TOTAL_EXTENT_COUNT+UDS.TOTAL_EXTDIR_COUNT)*UDS.PAGE_COUNT_IN_EXTENT))*TBS.PAGE_SIZE) /1024/1024 UNDO_USAGE
, DECODE(TX.LOG_TYPE, 1, 'REMOTE_TX_ID : '||REP_TX.REMOTE_TID, SUBSTR(ST.QUERY, 1, 30)) QUERY
FROM V$TXSEGS TXS
, V$TSSEGS TSS
, V$UDSEGS UDS
, V$TRANSACTION TX LEFT OUTER JOIN V$SESSION S ON TX.ID = S.TRANS_ID LEFT OUTER JOIN V$STATEMENT ST ON S.CURRENT_STMT_ID = ST.ID LEFT OUTER JOIN V$REPRECEIVER_TRANSTBL REP_TX ON TX.ID = REP_TX.LOCAL_TID LEFT OUTER JOIN V$REPRECEIVER REP ON REP_TX.REP_NAME = REP.REP_NAME
, V$TABLESPACES TBS
WHERE 1=1
AND UDS.SPACE_ID = 3
AND TXS.ID = UDS.TXSEG_ENTRY_ID
AND TXS.ID = TSS.TXSEG_ENTRY_ID
AND TXS.TRANS_ID = TX.ID
AND TBS.ID = UDS.SPACE_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| SESSION_ID | 트랜잭션을 수행한 세션 ID 또는 이중화 객체 이름이다. |
| TX_ID | 트랜잭션 ID이다. |
| TX_STATUS | 트랜잭션 상태이다. |
| SQL_STATUS | SQL 문 상태이다. |
| CLIENT_IP | 클라이언트 IP 주소와 프로세스 ID이다. |
| AUTOCOMMIT | 세션의 AUTOCOMMIT 모드이다. |
| UTRANS_TIMEOUT | 세션의 UTRANS_TIMEOUT 설정값이다. |
| LAST_QUERY_START_TIME | SQL 문을 시작한 시각이다. |
| UNDO_USAGE | 트랜잭션의 언두 사용량(MB 단위)이다. |
| QUERY | 언두를 사용하거나 접근한 트랜잭션에서 수행한 마지막 쿼리이다. |
[TS06] 전체 테이블스페이스 사용량#
전체 메모리 테이블스페이스, 메모리 테이블스페이스별, 디스크 테이블스페이스별 사용량을 한 번에 보여 준다. 이 쿼리는 Altibase 5.5.1 이상 버전에서 사용할 수 있다.
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((TOTAL/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, '' STATE
, '' 'AUTOEXTEND'
FROM (SELECT '' TBS_ID
, 'ALL_MEM_TBS' TBS_TYPE
, '-' TBS_NAME
, MEM_MAX_DB_SIZE MAX
, MEM_ALLOC_PAGE_COUNT*32 TOTAL
, (MEM_ALLOC_PAGE_COUNT-MEM_FREE_PAGE_COUNT)*32 ALLOC
, (SELECT SUM(FIXED_USED_MEM + VAR_USED_MEM) FROM V$MEMTBL_INFO) USED
FROM V$DATABASE )
UNION ALL
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((TOTAL/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT ID TBS_ID
, DECODE(TYPE, 0, 'MEM_SYS_DIC', 1, 'MEM_SYS_DATA', 2, 'MEM_USER_DATA', 8, 'VOL_USER_DATA') TBS_TYPE
, NAME TBS_NAME
, DECODE(M.MAXSIZE, 140737488322560, D.MEM_MAX_DB_SIZE , 0 , T.TOTAL_PAGE_COUNT * T.PAGE_SIZE, M.MAXSIZE) MAX
, M.ALLOC_PAGE_COUNT * T.PAGE_SIZE TOTAL
, NVL(M.ALLOC_PAGE_COUNT-M.FREE_PAGE_COUNT, T.TOTAL_PAGE_COUNT)*PAGE_SIZE ALLOC
, NVL(MT.USED, 0) USED
, DECODE(T.STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, DECODE(M.AUTOEXTEND_MODE, 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATABASE D
, V$TABLESPACES T
, (SELECT SPACE_ID
, SPACE_NAME
, ALLOC_PAGE_COUNT
, FREE_PAGE_COUNT
, DECODE(MAX_SIZE, 0, (SELECT VALUE1
FROM V$PROPERTY
WHERE NAME = 'VOLATILE_MAX_DB_SIZE'), MAX_SIZE) AS MAXSIZE
, AUTOEXTEND_MODE
FROM V$VOL_TABLESPACES
UNION ALL
SELECT SPACE_ID
, SPACE_NAME
, ALLOC_PAGE_COUNT
, FREE_PAGE_COUNT
, MAXSIZE
, AUTOEXTEND_MODE
FROM V$MEM_TABLESPACES ) M LEFT OUTER JOIN (SELECT TABLESPACE_ID, SUM((FIXED_USED_MEM + VAR_USED_MEM)) USED
FROM V$MEMTBL_INFO
GROUP BY TABLESPACE_ID ) MT ON M.SPACE_ID = MT.TABLESPACE_ID
WHERE T.ID = M.SPACE_ID)
UNION ALL
SELECT TBS_ID
, TBS_TYPE
, TBS_NAME
, TO_CHAR(MAX/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR(TOTAL/1024/1024, '999,999,999') 'TOTAL(MB)'
, TO_CHAR(ALLOC/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(USED/1024/1024, '999,999,999') 'USED(MB)'
, TO_CHAR((ROUND((USED/1024/1024), 0)/ROUND((MAX/1024/1024), 0))*100, '999.99') 'USAGE(%)'
, STATE
, AUTOEXTEND
FROM (SELECT T.ID TBS_ID
, DECODE(TYPE, 3, 'DISK_SYS_DATA', 4, 'DISK_USER_DATA', 5, 'DISK_SYS_TEMP', 6, 'DISK_USER_TEMP', 7, 'DISK_SYS_UNDO') TBS_TYPE
, NAME TBS_NAME
, D.MAX * PAGE_SIZE MAX
, TOTAL_PAGE_COUNT * PAGE_SIZE TOTAL
, DECODE(TYPE, 7, U.TOTAL_EXT_CNT * PROP.EXTENT_SIZE, ALLOCATED_PAGE_COUNT * PAGE_SIZE) ALLOC
, DECODE(TYPE, 3, NVL(DS.USED, 0) , 4, NVL(DS.USED, 0) , 7, (U.TX_EXT_CNT+U.USED_EXT_CNT+U.UNSTEALABLE_EXT_CNT) * PROP.EXTENT_SIZE , ALLOCATED_PAGE_COUNT * PAGE_SIZE ) USED
, DECODE(STATE, 1, 'OFFLINE', 2, 'ONLINE', 5, 'OFFLINE BACKUP', 6, 'ONLINE BACKUP', 128, 'DROPPED', 'DISCARDED') STATE
, D.AUTOEXTEND
FROM V$TABLESPACES T LEFT OUTER JOIN(SELECT SPACE_ID , SUM(TOTAL_USED_SIZE) USED FROM X$SEGMENT GROUP BY SPACE_ID) DS ON DS.SPACE_ID = T.ID
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND), 1, 'ON', 'OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID ) D
, V$DISK_UNDO_USAGE U
, (SELECT VALUE1 EXTENT_SIZE
FROM V$PROPERTY
WHERE NAME = 'SYS_UNDO_TBS_EXTENT_SIZE') PROP
WHERE T.ID = D.SPACEID )
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| MAX(MB) | 테이블스페이스에서 사용할 수 있는 최대 크기이다. |
| TOTAL(MB) | 테이블스페이스가 지금까지 할당받은 크기로, 체크포인트 이미지 파일 또는 데이터 파일의 크기와 같다. |
| ALLOC(MB) | 테이블스페이스가 지금까지 할당받은 페이지 중 '빈 페이지'를 제외한 '사용 중인 페이지'의 크기이다. |
| USED(MB) | 테이블스페이스의 사용 중인 페이지 중 실제로 데이터가 적재된 크기이다. |
| USAGE(%) | 전체 메모리 테이블스페이스(ALL_MEM_TBS)는 MAX 대비 TOTAL, 메모리 테이블스페이스는 TOTAL 대비 USED, 디스크 테이블스페이스는 MAX 대비 USED의 사용률이다. |
[TS07] 메모리 테이블스페이스 체크포인트 이미지 파일 경로#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT M.SPACE_ID TBS_ID
, SPACE_NAME TBS_NAME
, CHECKPOINT_PATH
FROM V$MEM_TABLESPACES M
, V$MEM_TABLESPACE_CHECKPOINT_PATHS C
WHERE M.SPACE_ID = C.SPACE_ID
;
[TS08] 메모리 테이블스페이스 체크포인트 이미지 파일#
메모리 테이블스페이스의 안정된(stable) 체크포인트 이미지 파일을 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT MEM_DATA_FILE DATAFILE_NAME
FROM V$STABLE_MEM_DATAFILES
;
[TS09] 디스크 테이블스페이스 데이터 파일#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT B.NAME TBS_NAME
, A.ID 'FILE#'
, A.NAME DATAFILE_NAME
, CURRSIZE*8/1024 'ALLOC(MB)'
, ROUND(CASE2(A.MAXSIZE=0, CURRSIZE, A.MAXSIZE)*8/1024) 'MAX(MB)'
, DECODE(AUTOEXTEND, 0, 'OFF', 'ON') 'AUTOEXTEND'
FROM V$DATAFILES A
, V$TABLESPACES B
WHERE B.ID = A.SPACEID
ORDER BY B.NAME, A.ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| FILE# | 데이터 파일의 번호이다. 디스크 테이블스페이스 하나는 데이터 파일을 여러 개 가질 수 있다. |
[TS10] 디스크 테이블스페이스 데이터 파일별 I/O#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT NAME TBS_NAME
, A.PHYRDS PHY_READ
, A.PHYWRTS PHY_WRITE
, A.PHYRDS+A.PHYWRTS PHY_TOTAL
, TRUNC(A.PHYRDS/READ_SUM*100,2) 'READ(%)'
, TRUNC(A.PHYWRTS/WRITE_SUM*100,2) 'WRITE(%)'
, TRUNC( (A.PHYRDS+A.PHYWRTS) / (READ_SUM+WRITE_SUM) * 100 , 2) 'TOTAL(%)'
, A.AVGIOTIM AVG_IO_TIME
FROM V$FILESTAT A
, V$DATAFILES B
, (SELECT SUM(PHYRDS) READ_SUM
, SUM(PHYWRTS) WRITE_SUM
FROM V$FILESTAT ) C
WHERE A.SPACEID = B.SPACEID
AND A.FILEID = B.ID
AND READ_SUM > 0
AND WRITE_SUM > 0
ORDER BY A.PHYRDS+A.PHYWRTS DESC, ROWNUM DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| PHY_READ | 물리적 읽기 I/O 발생 횟수이다. |
| PHY_WRITE | 물리적 쓰기 I/O 발생 횟수이다. |
| PHY_TOTAL | 물리적 I/O 발생 횟수이다. |
| READ(%) | 전체 물리적 읽기 I/O 대비 발생 비율이다. |
| WRITE(%) | 전체 물리적 쓰기 I/O 대비 발생 비율이다. |
| TOTAL(%) | 전체 물리적 I/O 대비 발생 비율이다. |
| AVG_IO_TIME | 평균 물리적 I/O 시간으로, 단위는 밀리초이다. |
[TS11] 디스크 테이블스페이스 데이터 파일별 단일 페이지 읽기 I/O#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT B.NAME TBS_NAME
, A.SINGLEBLKRDS READ_CNT_PER_PAGE
, A.SINGLEBLKRDTIM READ_TIME_PER_PAGE
, TRUNC(A.SINGLEBLKRDTIM/A.SINGLEBLKRDS,2) AVERAGE_TIME
FROM V$FILESTAT A
, V$DATAFILES B
WHERE A.SPACEID = B.SPACEID
AND A.FILEID = B.ID
AND A.SINGLEBLKRDS > 0
ORDER BY AVERAGE_TIME DESC
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| READ_CNT_PER_PAGE | 단일 페이지 읽기 횟수이다. |
| READ_TIME_PER_PAGE | 단일 페이지 읽기 시간으로, 단위는 밀리초이다. |
| AVERAGE_TIME | 단일 페이지 평균 읽기 시간으로, 단위는 밀리초이다. |
[TS12] 임시 테이블스페이스 사용량#
이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있다.
SELECT SUM(NORMAL_AREA_SIZE) SUM_NORMAL_AREA_SIZE
FROM X$TEMPTABLE_STATS
WHERE DROP_TIME = '19700101_090000'
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| NORMAL_AREA_SIZE | 사용한 임시 테이블스페이스 공간의 크기이다. |
[TS13] 트랜잭션별 임시 테이블스페이스 사용량#
이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있다.
SELECT NORMAL_AREA_SIZE
FROM X$TEMPTABLE_STATS T
, V$STATEMENT STMT
WHERE T.TRANSACTION_ID = STMT.TX_ID
;
[TS14] 전체 테이블스페이스 상태#
이 쿼리는 Altibase 5.3.3 이상 버전에서 사용할 수 있다.
SELECT NAME TBS_NAME
, DECODE(STATE, 1, 'OFFLINE',
2, 'ONLINE',
5, 'OFFLINE BACKUP',
6, 'ONLINE BACKUP',
128, 'DROPPED', 'DISCARD') STATE
FROM V$TABLESPACES
;
버퍼 풀#
버퍼 풀 정보를 확인하는 쿼리를 소개한다.
[DB01] 버퍼 풀 히트율#
SELECT HIT_RATIO 'HIT_RATIO(%)' FROM V$BUFFPOOL_STAT ;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| HIT_RATIO(%) | 구동한 뒤부터 버퍼 풀에 이미 적재된 페이지를 재사용한 비율이다. 이 값이 작을수록 물리적 읽기(read page) 횟수가 많다는 뜻이며, 물리적 읽기가 많으면 시스템이 쿼리를 빠르게 처리하지 못한다. 이 칼럼은 (GET_PAGES + FIX_PAGES - READ_PAGES) / (GET_PAGES + FIX_PAGES)로 계산한다. |
객체#
데이터베이스 객체 정보를 확인하는 쿼리를 소개한다.
[OB01] 메모리 테이블 사용량#
메모리 테이블의 사용량을 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 6.5.1 이상#
SELECT MT.USER_NAME
, MT.TABLE_NAME
, MT.PARTITION_NAME
, TBS.NAME TBS_NAME
, TO_CHAR((MU.FIXED_ALLOC_MEM+MU.VAR_ALLOC_MEM)/1024/1024, '999,999,999.9') 'ALLOC(MB)'
, TO_CHAR((MU.FIXED_USED_MEM+MU.VAR_USED_MEM)/1024/1024, '999,999,999.9') 'USED(MB)'
, TO_CHAR(((MU.FIXED_USED_MEM+MU.VAR_USED_MEM)/(MU.FIXED_ALLOC_MEM+MU.VAR_ALLOC_MEM))*100, '999.9') 'USAGE(%)'
FROM (SELECT U.USER_NAME
, T.TABLE_NAME
, DECODE(T.IS_PARTITIONED, 'F', T.TABLE_OID, 'T', P.PARTITION_OID) TABLE_OID
, DECODE(T.IS_PARTITIONED, 'F', RPAD('-', 14), 'T', P.PARTITION_NAME) PARTITION_NAME
, DECODE(T.IS_PARTITIONED, 'F', T.TBS_ID, 'T', P.TBS_ID) TBS_ID
FROM SYSTEM_.SYS_USERS_ U
, SYSTEM_.SYS_TABLES_ T LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ P ON T.TABLE_ID = P.TABLE_ID
WHERE 1=1
AND U.USER_ID <> 1
AND U.USER_ID = T.USER_ID
AND T.TBS_ID IN (SELECT ID FROM V$TABLESPACES WHERE TYPE IN (1, 2, 8))
) MT
, V$MEMTBL_INFO MU
, V$TABLESPACES TBS
WHERE 1=1
AND MT.TABLE_OID = MU.TABLE_OID
AND TBS.ID = MT.TBS_ID
ORDER BY 1, 2, 3
;
Altibase 4 ~ 6.3.1#
SELECT A.USER_NAME
, B.TABLE_NAME
, D.NAME TBS_NAME
, TO_CHAR((C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM)/1024/1024, '999,999,999.9') 'ALLOC(MB)'
, TO_CHAR((C.FIXED_USED_MEM+C.VAR_USED_MEM)/1024/1024, '999,999,999.9') 'USED(MB)'
, TO_CHAR(((C.FIXED_USED_MEM+C.VAR_USED_MEM)/(C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM))*100, '999.9') 'USAGE(%)'
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, V$MEMTBL_INFO C
, V$TABLESPACES D
WHERE 1=1
AND A.USER_NAME <> 'SYSTEM_'
AND B.TABLE_TYPE = 'T'
AND A.USER_ID = B.USER_ID
AND B.TABLE_OID = C.TABLE_OID
AND B.TBS_ID = D.ID
ORDER BY USER_NAME, TBS_NAME, TABLE_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| USER_NAME | 테이블 소유자이다. |
| TABLE_NAME | 테이블 이름이다. |
| PARTITION_NAME | 파티션드 테이블이면 파티션 이름이다. 메모리 파티션드 테이블은 Altibase 6.5.1부터 지원한다. |
| TBS_NAME | 테이블을 생성할 때 지정한 테이블스페이스 이름이다. |
| ALLOC(MB) | 메모리 테이블이 할당받은 페이지의 합계이다. |
| USED(MB) | 메모리 테이블이 할당받은 페이지 중 '실제로 데이터가 적재된 페이지'의 합계이다. 예를 들어 ALLOC이 100MB인 메모리 테이블에서 전체 데이터를 DELETE하면 ALLOC은 100MB로 그대로지만 USED는 0에 가까워진다. TRUNCATE를 수행하면 ALLOC을 줄일 수 있다. |
| USAGE(%) | 메모리 테이블에 할당된 페이지 중 실제로 데이터가 적재된 페이지의 백분율(USED/ALLOC)이다. |
[OB02] 큐#
큐 테이블의 사용량을 보여 준다. 칼럼 설명은 [OB01] 메모리 테이블 사용량을 참고한다.
SELECT A.USER_NAME
, B.TABLE_NAME
, D.NAME TABLESPACE_NAME
, C.TABLE_OID
, TO_CHAR((C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM)/1024/1024, '999,999,999.9') 'ALLOC(MB)'
, TO_CHAR((C.FIXED_USED_MEM+C.VAR_USED_MEM)/1024/1024, '999,999,999.9') 'USED(MB)'
, TO_CHAR(((C.FIXED_USED_MEM+C.VAR_USED_MEM)/(C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM))*100, '999.9') 'USAGE(%)'
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, V$MEMTBL_INFO C
, V$TABLESPACES D
WHERE 1=1
AND A.USER_NAME <> 'SYSTEM_'
AND B.TABLE_TYPE = 'Q'
AND A.USER_ID = B.USER_ID
AND B.TABLE_OID = C.TABLE_OID
AND B.TBS_ID = D.ID
;
[OB03] 사용 효율이 낮은 메모리 테이블#
할당받은 전체 페이지에 비해 실제 사용량이 적은 메모리 테이블을 보여 준다. 이 쿼리는 할당받은 페이지의 전체 크기가 1GB 이상이고 USAGE가 50% 이하인 메모리 테이블을 출력한다.
Altibase 6.5.1 이상#
SELECT MT.USER_NAME
, MT.TABLE_NAME
, MT.PARTITION_NAME
, TBS.NAME TBS_NAME
, TO_CHAR((MU.FIXED_ALLOC_MEM+MU.VAR_ALLOC_MEM)/1024/1024, '999,999,999.9') 'ALLOC(MB)'
, TO_CHAR((MU.FIXED_USED_MEM+MU.VAR_USED_MEM)/1024/1024, '999,999,999.9') 'USED(MB)'
, TO_CHAR(((MU.FIXED_USED_MEM+MU.VAR_USED_MEM)/(MU.FIXED_ALLOC_MEM+MU.VAR_ALLOC_MEM))*100, '999.9') 'USAGE(%)'
FROM (SELECT U.USER_NAME
, T.TABLE_NAME
, DECODE(T.IS_PARTITIONED, 'F', T.TABLE_OID, 'T', P.PARTITION_OID) TABLE_OID
, DECODE(T.IS_PARTITIONED, 'F', RPAD('-', 14), 'T', P.PARTITION_NAME) PARTITION_NAME
, DECODE(T.IS_PARTITIONED, 'F', T.TBS_ID, 'T', P.TBS_ID) TBS_ID
FROM SYSTEM_.SYS_USERS_ U
, SYSTEM_.SYS_TABLES_ T LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ P ON T.TABLE_ID = P.TABLE_ID
WHERE 1=1
AND U.USER_ID <> 1
AND U.USER_ID = T.USER_ID
AND T.TBS_ID IN (SELECT ID FROM V$TABLESPACES WHERE TYPE IN (1, 2, 8))
) MT
, V$MEMTBL_INFO MU
, V$TABLESPACES TBS
WHERE 1=1
AND MT.TABLE_OID = MU.TABLE_OID
AND TBS.ID = MT.TBS_ID
AND ROUND((FIXED_ALLOC_MEM+VAR_ALLOC_MEM)/1024/1024, 2) >= 1024 -- 메모리 테이블에 할당된 페이지가 1GB 이상
AND ROUND((FIXED_USED_MEM+VAR_USED_MEM)/(FIXED_ALLOC_MEM+VAR_ALLOC_MEM+0.01)*100, 2) <= 50 -- USAGE가 50% 이하
ORDER BY 1, 2, 3
;
Altibase 4 ~ 6.3.1#
SELECT C.USER_NAME
, B.TABLE_NAME
, TO_CHAR((C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM)/1024/1024, '999,999,999.9') 'ALLOC(MB)'
, TO_CHAR((C.FIXED_USED_MEM+C.VAR_USED_MEM)/1024/1024, '999,999,999.9') 'USED(MB)'
, TO_CHAR(((C.FIXED_USED_MEM+C.VAR_USED_MEM)/(C.FIXED_ALLOC_MEM+C.VAR_ALLOC_MEM))*100, '999.9') 'USAGE(%)'
FROM V$MEMTBL_INFO A
, SYSTEM_.SYS_TABLES_ B
, SYSTEM_.SYS_USERS_ C
WHERE A.TABLE_OID = B.TABLE_OID
AND B.USER_ID = C.USER_ID
AND ROUND((FIXED_ALLOC_MEM+VAR_ALLOC_MEM)/1024/1024, 2) >= 1024 -- 메모리 테이블에 할당된 페이지가 1GB 이상
AND ROUND((FIXED_USED_MEM+VAR_USED_MEM)/(FIXED_ALLOC_MEM+VAR_ALLOC_MEM+0.01)*100, 2) <= 50 -- USAGE가 50% 이하
AND B.USER_ID <> 1
ORDER BY 'FREE(MB)' DESC
;
ALLOC(MB), USED(MB), USAGE(%) 칼럼의 의미는 [OB01] 메모리 테이블 사용량과 같다.
[OB04] 메모리 인덱스, 큐 인덱스 사용량#
메모리 테이블의 인덱스와 큐 테이블의 인덱스 사용량을 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT U.USER_NAME
, T.TABLE_NAME
, B.INDEX_NAME
, LPAD(I.IS_PARTITIONED, 14) INDEX_PARTITIONED
, ROUND(((USED_NODE_COUNT + PREPARE_NODE_COUNT) / 15 * 32768)/1024/1024, 1) AS 'SIZE(MB)'
FROM V$MEM_BTREE_HEADER B
, SYSTEM_.SYS_INDICES_ I
, SYSTEM_.SYS_TABLES_ T
, SYSTEM_.SYS_USERS_ U
WHERE 1=1
AND B.INDEX_ID = I.INDEX_ID
AND I.TABLE_ID = T.TABLE_ID
AND B.INDEX_TBS_ID <> 0
AND U.USER_ID = T.USER_ID
ORDER BY TABLE_NAME, B.INDEX_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| INDEX_PARTITIONED | 파티션드 인덱스 여부로, F는 논파티션드 인덱스, T는 파티션드 인덱스이다. 메모리 파티션드 인덱스는 Altibase 6.5.1부터 지원한다. |
| SIZE(MB) | 인덱스 노드 수로 계산한 인덱스 크기이다. 인덱스 노드 15개당 페이지 하나를 사용하며, 페이지 크기는 32KB이다. 노드당 사용할 수 있는 슬롯 개수는 Altibase 버전마다 다르므로, 같은 데이터라도 버전에 따라 인덱스 크기가 다를 수 있다. |
[OB05] 디스크 테이블#
디스크 테이블의 사용량을 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5.3.3 이상#
SELECT U.USER_NAME USER_NAME
, TBL.TABLE_NAME TABLE_NAME
, DECODE(TBL.IS_PARTITIONED, 'T', TBL.PARTITION_NAME, 'F', '-') PARTITIONED_TABLE
, TBS.NAME TBS_NAME
, TO_CHAR((D.MAX * TBS.PAGE_SIZE)/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR((TBS.EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.TOTAL_EXTENT_COUNT)/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(SEG.TOTAL_USED_SIZE/1024/1024, '999,999,999') 'USED(MB)'
FROM (SELECT TBL.USER_ID
, DECODE(TBL.IS_PARTITIONED, 'F', TBL.TABLE_OID, 'T', PT.PARTITION_OID) TABLE_OID
, TBL.TABLE_NAME
, PT.PARTITION_NAME
, DECODE(TBL.IS_PARTITIONED, 'F', TBL.TBS_ID, 'T', PT.TBS_ID) TBS_ID
, TBL.IS_PARTITIONED
FROM SYSTEM_.SYS_TABLES_ TBL LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ PT ON TBL.TABLE_ID = PT.TABLE_ID
WHERE TBL.TABLE_TYPE = 'T'
) TBL
, (SELECT S.TABLE_OID, SUM(S.TOTAL_EXTENT_COUNT) TOTAL_EXTENT_COUNT, SUM(S.TOTAL_USED_SIZE) TOTAL_USED_SIZE
FROM X$SEGMENT S
WHERE S.SEGMENT_TYPE IN (6, 7) /* 6 : 테이블, 7 : LOB 데이터(6.1.1 이상), 5 : 인덱스 */
GROUP BY S.TABLE_OID) SEG
, SYSTEM_.SYS_USERS_ U
, V$TABLESPACES TBS
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND),1,'ON','OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
WHERE 1=1
AND SEG.TABLE_OID = TBL.TABLE_OID
AND U.USER_ID = TBL.USER_ID
AND D.SPACEID = TBL.TBS_ID
AND TBS.ID = TBL.TBS_ID
ORDER BY USER_NAME, TABLE_NAME, PARTITIONED_TABLE
;
Altibase 5.1.5#
SELECT U.USER_NAME USER_NAME
, TBL.TABLE_NAME TABLE_NAME
, DECODE(TBL.IS_PARTITIONED, 'T', TBL.PARTITION_NAME, 'F', '-') PARTITIONED_TABLE
, TBS.NAME TBS_NAME
, TO_CHAR((D.MAX * TBS.PAGE_SIZE)/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR((TBS.EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_TOTAL_COUNT)/1024/1024, '999,999,999') 'ALLOC(MB)'
FROM (SELECT TBL.USER_ID
, DECODE(TBL.IS_PARTITIONED, 'F', TBL.TABLE_OID, 'T', PT.PARTITION_OID) TABLE_OID
, TBL.TABLE_NAME
, PT.PARTITION_NAME
, DECODE(TBL.IS_PARTITIONED, 'F', TBL.TBS_ID, 'T', PT.TBS_ID) TBS_ID
, TBL.IS_PARTITIONED
FROM SYSTEM_.SYS_TABLES_ TBL LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ PT ON TBL.TABLE_ID = PT.TABLE_ID
) TBL
, V$SEGMENT SEG
, SYSTEM_.SYS_USERS_ U
, V$TABLESPACES TBS
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND),1,'ON','OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
WHERE 1=1
AND SEG.SEGMENT_TYPE = 'TABLE' /* 'TABLE' : 테이블, 'INDEX' : 인덱스 */
AND SEG.TABLE_OID = TBL.TABLE_OID
AND U.USER_ID = TBL.USER_ID
AND D.SPACEID = TBL.TBS_ID
AND TBS.ID = TBL.TBS_ID
ORDER BY USER_NAME, PARTITIONED, TABLE_NAME, PARTITIONED_TABLE
;
Altibase 4.3.9#
SELECT U.USER_NAME 'USER_NAME'
, TBL.TABLE_NAME 'TABLE_NAME'
, TBS.NAME 'TBS_NAME'
, TO_CHAR((TBS.TOTAL_PAGE_COUNT * TBS.PAGE_SIZE)/1024/1024 , '999,999,999') 'TBS_MAX(MB)'
, TO_CHAR((TBS.A_EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_TOTAL_COUNT)/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR((TBS.A_EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_FULL_COUNT)/1024/1024, '999,999,999') 'USED(MB)'
FROM X$SEGMENT SEG
, SYSTEM_.SYS_TABLES_ TBL
, V$TABLESPACES TBS
, SYSTEM_.SYS_USERS_ U
WHERE 1=1
AND SEG.TABLE_OID = TBL.TABLE_OID
AND SEG.SPACE_ID = TBL.TBS_ID
AND SEG.SPACE_ID = TBS.ID
AND TBL.USER_ID = U.USER_ID
AND TBL.TABLE_TYPE = 'T'
AND SEG.SEGMENT_TYPE = 6
ORDER BY USER_NAME, TABLE_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TABLE_NAME | 테이블 이름이다. |
| PARTITIONED_TABLE | 파티션드 테이블이면 파티션 이름을 보여 준다. 논파티션드 테이블은 '-'이다. |
| TBS_NAME | 테이블을 생성할 때 지정한 테이블스페이스 이름이다. 파티션에 테이블스페이스를 지정했으면 파티션에 지정한 테이블스페이스 이름을 보여 준다. |
| MAX | 테이블이 속한 테이블스페이스의 최대 크기이다. |
| ALLOC | 테이블이 할당받은 전체 크기이다. |
| USED | 테이블이 할당받은 공간 중 데이터가 들어 있는 크기이다. 데이터를 DELETE하면 해당 공간은 재사용할 수 있지만, 디스크 테이블은 메모리 테이블과 달리 DELETE를 수행해도 USED가 줄지 않는다. AGING 작업을 수행하지 않으면 ALLOC과 USED는 항상 같은 값을 가진다. DELETE로 재사용할 수 있게 된 공간을 제외한 실제 USED를 확인하려면 ALTER TABLE table_name AGING;으로 AGING 작업을 수행한다. 이 작업은 수행 중에 테이블에 X 잠금을 획득해 해당 테이블에 대한 다른 요청을 대기시키므로 주의한다. |
[OB06] 디스크 인덱스 사용량#
디스크 인덱스의 사용량을 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5.3.3 이상#
SELECT U.USER_NAME USER_NAME
, I_LIST.TABLE_NAME
, DECODE(I_LIST.PARTITION_NAME, NULL, '-', I_LIST.PARTITION_NAME) PARTITIONED_NAME
, I_LIST.INDEX_NAME INDEX_NAME
, DECODE(I_LIST.INDEX_PARTITION_NAME, NULL, '-', I_LIST.INDEX_PARTITION_NAME) PARTITIONED_INDEX
, TBS.NAME TBS_NAME
, TO_CHAR((D.MAX * TBS.PAGE_SIZE)/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR((TBS.EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.TOTAL_EXTENT_COUNT)/1024/1024, '999,999,999') 'ALLOC(MB)'
, TO_CHAR(SEG.TOTAL_USED_SIZE/1024/1024, '999,999,999') 'USED(MB)'
FROM (SELECT T.TABLE_NAME
, PT.PARTITION_NAME
, I.INDEX_NAME
, PI.INDEX_PARTITION_NAME
, DECODE(T.IS_PARTITIONED, 'F', I.TABLE_ID, 'T', PT.TABLE_ID) TABLE_ID
, DECODE(T.IS_PARTITIONED, 'F', T.TABLE_OID, 'T', PT.PARTITION_OID) TABLE_OID
, DECODE(I.IS_PARTITIONED, 'F', I.TBS_ID, 'T', PI.TBS_ID) TBS_ID
, I.INDEX_ID
, T.USER_ID
FROM SYSTEM_.SYS_INDICES_ I LEFT OUTER JOIN SYSTEM_.SYS_INDEX_PARTITIONS_ PI ON PI.INDEX_ID = I.INDEX_ID
LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ PT ON PT.PARTITION_ID = PI.TABLE_PARTITION_ID
LEFT OUTER JOIN SYSTEM_.SYS_TABLES_ T ON T.TABLE_ID = I.TABLE_ID ) I_LIST
, X$SEGMENT SEG
, V$INDEX I
, V$TABLESPACES TBS
, SYSTEM_.SYS_USERS_ U
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND),1,'ON','OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
WHERE 1=1
AND SEG.TABLE_OID = I.TABLE_OID
AND SEG.SEGMENT_PID = I.INDEX_SEG_PID
AND SEG.SPACE_ID = I_LIST.TBS_ID
AND I_LIST.INDEX_ID = I.INDEX_ID
AND I_LIST.TABLE_OID = I.TABLE_OID
AND I_LIST.TBS_ID = TBS.ID
AND D.SPACEID = I_LIST.TBS_ID
AND U.USER_ID = I_LIST.USER_ID
ORDER BY I_LIST.TABLE_NAME, I_LIST.INDEX_NAME, I_LIST.PARTITION_NAME, I_LIST.INDEX_PARTITION_NAME
;
Altibase 5.1.5#
SELECT U.USER_NAME USER_NAME
, I_LIST.TABLE_NAME
, DECODE(I_LIST.PARTITION_NAME, NULL, '-', I_LIST.PARTITION_NAME) PARTITIONED_NAME
, I_LIST.INDEX_NAME INDEX_NAME
, DECODE(I_LIST.INDEX_PARTITION_NAME, NULL, '-', I_LIST.INDEX_PARTITION_NAME) PARTITIONED_INDEX
, TBS.NAME TBS_NAME
, TO_CHAR((D.MAX * TBS.PAGE_SIZE)/1024/1024, '999,999,999') 'MAX(MB)'
, TO_CHAR((TBS.EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_TOTAL_COUNT)/1024/1024, '999,999,999') 'ALLOC(MB)'
FROM (SELECT T.TABLE_NAME
, PT.PARTITION_NAME
, I.INDEX_NAME
, PI.INDEX_PARTITION_NAME
, DECODE(T.IS_PARTITIONED, 'F', I.TABLE_ID, 'T', PT.TABLE_ID) TABLE_ID
, DECODE(T.IS_PARTITIONED, 'F', T.TABLE_OID, 'T', PT.PARTITION_OID) TABLE_OID
, DECODE(I.IS_PARTITIONED, 'F', I.TBS_ID, 'T', PI.TBS_ID) TBS_ID
, I.INDEX_ID
, T.USER_ID
FROM SYSTEM_.SYS_INDICES_ I LEFT OUTER JOIN SYSTEM_.SYS_INDEX_PARTITIONS_ PI ON PI.INDEX_ID = I.INDEX_ID
LEFT OUTER JOIN SYSTEM_.SYS_TABLE_PARTITIONS_ PT ON PT.PARTITION_ID = PI.TABLE_PARTITION_ID
LEFT OUTER JOIN SYSTEM_.SYS_TABLES_ T ON T.TABLE_ID = I.TABLE_ID ) I_LIST
, V$SEGMENT SEG
, V$INDEX I
, V$TABLESPACES TBS
, SYSTEM_.SYS_USERS_ U
, (SELECT SPACEID
, SUM(DECODE(MAXSIZE, 0, CURRSIZE, MAXSIZE)) AS MAX
, DECODE(MAX(AUTOEXTEND),1,'ON','OFF') 'AUTOEXTEND'
FROM V$DATAFILES
GROUP BY SPACEID) D
WHERE 1=1
AND SEG.TABLE_OID = I.TABLE_OID
AND SEG.SEGMENT_PID = I.INDEX_SEG_PID
AND SEG.SPACE_ID = I_LIST.TBS_ID
AND I_LIST.INDEX_ID = I.INDEX_ID
AND I_LIST.TABLE_OID = I.TABLE_OID
AND I_LIST.TBS_ID = TBS.ID
AND D.SPACEID = I_LIST.TBS_ID
AND U.USER_ID = I_LIST.USER_ID
ORDER BY I_LIST.TABLE_NAME, I_LIST.INDEX_NAME, I_LIST.PARTITION_NAME, I_LIST.INDEX_PARTITION_NAME
;
Altibase 4.3.9#
SELECT U.USER_NAME AS 'USER_NAME'
, TBL.TABLE_NAME AS 'TABLE_NAME'
, IDX.INDEX_NAME AS 'INDEX_NAME'
, TBS.NAME AS 'TBS_NAME'
, TO_CHAR((TBS.TOTAL_PAGE_COUNT * TBS.PAGE_SIZE)/1024/1024 , '999,999,999') AS 'TBS_MAX(MB)'
, TO_CHAR((TBS.A_EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_TOTAL_COUNT)/1024/1024, '999,999,999') AS 'ALLOC(MB)'
, TO_CHAR((TBS.A_EXTENT_PAGE_COUNT * TBS.PAGE_SIZE * SEG.EXTENT_FULL_COUNT )/1024/1024, '999,999,999') AS 'USED(MB)'
FROM X$SEGMENT SEG
, V$INDEX I
, SYSTEM_.SYS_INDICES_ IDX
, SYSTEM_.SYS_TABLES_ TBL
, V$TABLESPACES TBS
, SYSTEM_.SYS_USERS_ U
WHERE SEG.TABLE_OID = I.TABLE_OID
AND SEG.SEGMENT_DESC = I.INDEX_SEG_DESC
AND I.INDEX_ID = IDX.INDEX_ID
AND IDX.TABLE_ID = TBL.TABLE_ID
AND SEG.SPACE_ID = IDX.TBS_ID
AND SEG.SPACE_ID = TBS.ID
AND IDX.USER_ID = U.USER_ID
AND TBL.TABLE_TYPE = 'T'
AND SEG.SEGMENT_TYPE = 5
ORDER BY U.USER_NAME, TBL.TABLE_NAME, IDX.INDEX_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TABLE_NAME | 테이블 이름이다. |
| PARTITIONED_NAME | 파티션드 테이블이면 파티션 이름을 보여 준다. 논파티션드 테이블은 '-'이다. |
| INDEX_NAME | 인덱스 이름이다. |
| PARTITIONED_INDEX | 파티션드 인덱스이면 인덱스 파티션 이름을 보여 준다. 논파티션드 인덱스는 '-'이다. |
| TBS_NAME | 인덱스를 생성할 때 지정한 테이블스페이스 이름이다. 인덱스 파티션에 테이블스페이스를 지정했으면 해당 테이블스페이스 이름을 보여 준다. |
| MAX(MB) | 인덱스가 속한 테이블스페이스의 최대 크기이다. |
| ALLOC(MB) | 인덱스가 할당받은 전체 크기이다. |
| USED(MB) | 인덱스가 할당받은 공간 중 데이터가 들어 있는 크기이다. 데이터를 DELETE하면 해당 공간은 재사용할 수 있지만, DELETE를 수행해도 인덱스의 USED는 줄지 않는다. AGING 작업을 수행하지 않으면 ALLOC과 USED는 항상 같은 값을 가진다. DELETE로 재사용할 수 있게 된 공간을 제외한 실제 USED를 확인하려면 ALTER INDEX index_name AGING;으로 AGING 작업을 수행한다. 이 작업은 수행 중에 해당 테이블에 X 잠금을 획득해 테이블에 대한 다른 요청을 대기시키므로 주의한다. |
[OB07] 파티션드 테이블 정보#
파티션드 테이블의 파티셔닝 방법, 파티셔닝 기준 등 파티션드 테이블 정보를 보여 준다. 이 쿼리는 Altibase 6.5.1 이상 버전에서 사용할 수 있으며, 주석이 붙은 칼럼을 삭제하면 이전 버전에서도 사용할 수 있다.
SELECT U.USER_NAME
, T.TABLE_NAME
, P.PARTITION_NAME
, DECODE(PM.PARTITION_METHOD, 0, RPAD('RANGE', 16), 1, RPAD('HASH', 16), 2, RPAD('LIST', 16)) PARTITION_METHOD
, RPAD(P.PARTITION_ORDER, 15) PARTITION_ORDER
, RPAD(PM.ROW_MOVEMENT, 12) ROW_MOVEMENT
, P.PARTITION_MIN_VALUE
, P.PARTITION_MAX_VALUE
, RPAD(P.PARTITION_ACCESS, 6) 'ACCESS' -- Altibase 6.5.1 미만 버전에서는 삭제한다.
, TO_CHAR(P.CREATED, 'YYYY-MM-DD HH:MI:SS') CREATED -- Altibase 6.5.1 미만 버전에서는 삭제한다.
, TO_CHAR(P.LAST_DDL_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_DDL_TIME -- Altibase 6.5.1 미만 버전에서는 삭제한다.
FROM SYSTEM_.SYS_TABLES_ T
, SYSTEM_.SYS_TABLE_PARTITIONS_ P
, SYSTEM_.SYS_PART_TABLES_ PM
, SYSTEM_.SYS_USERS_ U
WHERE 1=1
AND U.USER_ID = T.USER_ID
AND T.TABLE_ID = P.TABLE_ID
AND PM.TABLE_ID = T.TABLE_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| PARTITION_METHOD | 파티션드 테이블의 파티셔닝 방법이다. |
| PARTITION_ORDER | 해시 파티션의 순서이다. |
| ROW_MOVEMENT | 레코드를 갱신해 파티션 키 칼럼의 값이 다른 파티션에 속하는 값으로 바뀌었을 때, 해당 레코드를 다른 파티션으로 자동 이동하도록 허용하는지 보여 준다. T는 허용, F는 허용하지 않음이다. 이 옵션은 파티션드 테이블을 생성할 때 설정한다. |
| PARTITION_MIN_VALUE | 범위(range) 파티션에서는 파티션의 최소 기준값을 문자열로 보여 준다. 리스트(list) 파티션은 PARTITION_MIN_VALUE와 PARTITION_MAX_VALUE가 같고, 해시(hash) 파티션은 둘 다 NULL이다. |
| PARTITION_MAX_VALUE | 범위 파티션에서는 파티션의 최대 기준값을 문자열로 보여 준다. 리스트 파티션은 PARTITION_MIN_VALUE와 PARTITION_MAX_VALUE가 같고, 해시 파티션은 둘 다 NULL이다. |
| ACCESS | 파티션 데이터의 접근 모드이다. R은 읽기 전용, W는 읽기/쓰기(기본값), A는 읽기/추가 모드이다. Altibase 6.5.1부터 제공한다. |
| CREATED | 파티션을 생성한 시각이다. Altibase 6.5.1부터 제공한다. |
| LAST_DDL_TIME | 파티션에 마지막으로 DDL을 수행한 시각이다. Altibase 6.5.1부터 제공한다. |
[OB08] 시퀀스#
시퀀스 정보를 보여 준다.
SELECT USER_NAME
, TABLE_NAME SEQ_NAME
, MIN_SEQ MIN
, CURRENT_SEQ
, MAX_SEQ MAX
, INCREMENT_SEQ INCREMENT
, IS_CYCLE
, CACHE_SIZE CACHE
FROM V$SEQ A
, SYSTEM_.SYS_USERS_ B
, SYSTEM_.SYS_TABLES_ C
WHERE 1=1
AND A.SEQ_OID = C.TABLE_OID
AND B.USER_ID = C.USER_ID
AND B.USER_NAME <> 'SYSTEM_'
;
[OB09] 시노님#
시노님 정보를 보여 준다. 버전에 따라 쿼리가 다르므로 버전에 맞는 쿼리를 사용한다.
Altibase 5 이상#
SELECT NVL(U.USER_NAME, 'PUBLIC') SYNONYM_OWNER
, S.SYNONYM_NAME
, S.OBJECT_OWNER_NAME OBJECT_OWNER
, S.OBJECT_NAME
, TO_CHAR(S.LAST_DDL_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_DDL_TIME
FROM SYSTEM_.SYS_SYNONYMS_ S
LEFT OUTER JOIN SYSTEM_.SYS_USERS_ U ON S.SYNONYM_OWNER_ID = U.USER_ID
WHERE 1=1
--AND U.USER_ID <> 0 -- PUBLIC 시노님을 제외하려면 이 줄의 주석을 해제한다.
;
Altibase 4.3.9#
SELECT NVL(U.USER_NAME, 'PUBLIC') SYNONYM_OWNER
, S.SYNONYM_NAME
, S.SCHEMA_NAME OBJECT_OWNER
, S.OBJECT_NAME
FROM SYSTEM_.SYS_SYNONYMS_ S LEFT OUTER JOIN SYSTEM_.SYS_USERS_ U ON S.USER_ID = U.USER_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| SYNONYM_OWNER | 시노님을 생성한 데이터베이스 사용자이다. 값이 'PUBLIC'이면 데이터베이스를 생성할 때 누구나 사용할 수 있도록 기본으로 만들어지는 시노님이다. |
| OBJECT_OWNER | 시노님 대상 객체의 소유자이다. |
| OBJECT_NAME | 시노님 대상 객체의 이름이다. |
| LAST_DDL_TIME | 시노님에 마지막으로 DDL을 수행한 시각이다. Altibase 5부터 제공한다. |
[OB10] PSM#
저장 프로시저와 저장 함수의 정보를 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있으며, LAST_DDL_TIME 칼럼을 삭제하면 Altibase 4에서도 사용할 수 있다.
SELECT A.USER_NAME
, PROC_NAME PSM_NAME
, DECODE(OBJECT_TYPE, 0, 'PROCEDURE', 1, 'FUNCTION', 3, 'TYPESET') PSM_TYPE
, DECODE(STATUS, 0, 'VALID', 'INVALID') STATUS
, TO_CHAR(B.CREATED, 'YYYY-MM-DD HH:MI:SS') CREATED
, TO_CHAR(B.LAST_DDL_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_DDL_TIME -- Altibase 4에서는 삭제한다.
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_PROCEDURES_ B
WHERE 1=1
AND A.USER_ID = B.USER_ID
AND A.USER_NAME <> 'SYSTEM_'
ORDER BY 1, 2, 3
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| STATUS | 컴파일 상태이다. INVALID는 다시 컴파일해야 하는 상태이다. |
[OB11] PSM 생성 구문#
PROC_NAME 조건에 PSM 이름을 입력하면 해당 PSM의 생성 구문을 보여 준다.
SELECT PARSE
FROM SYSTEM_.SYS_PROC_PARSE_
WHERE PROC_OID = (SELECT PROC_OID
FROM SYSTEM_.SYS_PROCEDURES_
WHERE PROC_NAME = 'psm_name') -- 조회할 PSM 이름을 입력한다.
ORDER BY SEQ_NO
;
[OB12] 뷰#
뷰 정보를 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있으며, CREATED와 LAST_DDL_TIME 칼럼을 삭제하면 Altibase 4에서도 사용할 수 있다.
SELECT A.USER_NAME
, B.TABLE_NAME VIEW_NAME
, DECODE(C.STATUS, 0, 'VALID', 'INVALID') STATUS
, TO_CHAR(B.CREATED, 'YYYY-MM-DD HH:MI:SS') CREATED -- Altibase 4에서는 삭제한다.
, TO_CHAR(B.LAST_DDL_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_DDL_TIME -- Altibase 4에서는 삭제한다.
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, SYSTEM_.SYS_VIEWS_ C
WHERE 1=1
AND A.USER_ID = B.USER_ID
AND B.TABLE_ID = C.VIEW_ID
AND B.TABLE_TYPE = 'V'
;
[OB13] 뷰 생성 구문#
TABLE_NAME 조건에 뷰 이름을 입력하면 해당 뷰의 생성 구문을 보여 준다.
SELECT PARSE
FROM SYSTEM_.SYS_VIEW_PARSE_
WHERE VIEW_ID = (SELECT TABLE_ID
FROM SYSTEM_.SYS_TABLES_
WHERE TABLE_NAME = 'view_name') -- 조회할 뷰 이름을 입력한다.
ORDER BY SEQ_NO
;
[OB14] 패키지#
패키지 정보를 보여 준다. 이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있다.
SELECT A.USER_NAME
, PACKAGE_NAME
, DECODE(PACKAGE_TYPE, 6, 'PACKAGE_SPEC', 7, 'PACKAGE_BODY') PACKAGE_TYPE
, DECODE(STATUS, 0, 'VALID', 'INVALID') STATUS
, TO_CHAR(B.CREATED, 'YYYY-MM-DD HH:MI:SS') CREATED
, TO_CHAR(B.LAST_DDL_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_DDL_TIME
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_PACKAGES_ B
WHERE 1=1
AND A.USER_ID = B.USER_ID
AND A.USER_NAME <> 'SYSTEM_'
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| PACKAGE_TYPE | 패키지 유형으로, 스펙(PACKAGE_SPEC)인지 바디(PACKAGE_BODY)인지 나타낸다. |
| STATUS | 컴파일 상태이다. INVALID는 다시 컴파일해야 하는 상태이다. |
[OB15] 패키지 서브프로그램#
패키지에 포함된 서브프로그램(저장 프로시저와 저장 함수)의 정보를 보여 준다. 이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있다.
SELECT USER_NAME
, OBJECT_NAME
, PACKAGE_NAME
, DECODE(SUB_TYPE, 0, 'PROCEDURE', 1, 'FUNCTION') SUB_TYPE
, PARA_NAME
, PARA_ORDER
, DECODE(INOUT_TYPE, 0, 'IN', 1, 'OUT', 2, 'IN OUT') INOUT_TYPE
, DATA_TYPE
, SIZE
, DEFAULT_VAL
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_PACKAGE_PARAS_ B
WHERE 1=1
AND A.USER_ID = B.USER_ID
AND A.USER_NAME <> 'SYSTEM_'
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| SUB_TYPE | 서브프로그램 유형으로, PROCEDURE(0) 또는 FUNCTION(1)이다. |
| PARA_NAME | 서브프로그램 파라미터 이름이다. |
| PARA_ORDER | 서브프로그램 파라미터 순서로, 첫 번째 파라미터가 1이다. |
| INOUT_TYPE | 파라미터의 입출력 유형이다. |
| DATA_TYPE | 파라미터의 데이터 타입이다. |
| SIZE | 파라미터 타입의 크기이다. |
| DEFAULT_VAL | 파라미터의 기본값이다. |
[OB16] 패키지 생성 구문#
PACKAGE_NAME 조건에 패키지 이름을 입력하면 해당 패키지의 생성 구문을 보여 준다. 이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있다.
SELECT PARSE
, DECODE(PACKAGE_TYPE, 6, 'PACKAGE_SPEC', 7, 'PACKAGE_BODY') PACKAGE_TYPE
FROM SYSTEM_.SYS_PACKAGE_PARSE_
WHERE PACKAGE_OID IN (SELECT PACKAGE_OID
FROM SYSTEM_.SYS_PACKAGES_
WHERE PACKAGE_NAME = 'package_name') -- 조회할 패키지 이름을 입력한다.
ORDER BY SEQ_NO
;
[OB17] 트리거#
트리거 정보를 보여 준다. 이 쿼리는 Altibase 4.3.9 이상 버전에서 사용할 수 있다.
SELECT TR.USER_NAME
, T.TABLE_NAME
, TR.TRIGGER_NAME
, RPAD(DECODE(TR.IS_ENABLE, 0, 'NO',
1, 'YES'), 9) IS_ENABLE
, RPAD(DECODE(TR.EVENT_TIME, 1, 'BEFORE',
2, 'AFTER',
3, 'INSTEAD OF'), 10) EVENT_TIME
, RPAD(DECODE(TR.EVENT_TYPE, 1, 'INSERT',
2, 'DELETE',
4, 'UPDATE'), 10) EVENT_TYPE
, DECODE(TR.GRANULARITY, 1, 'FOR EACH ROW',
2, 'FOR EACH STATEMENT') GRANULARITY
FROM SYSTEM_.SYS_TABLES_ T
, SYSTEM_.SYS_TRIGGERS_ TR
WHERE 1=1
AND TR.TABLE_ID = T.TABLE_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TABLE_NAME | 트리거를 정의한 테이블 이름이다. |
| IS_ENABLE | 트리거 동작 여부이다. |
| EVENT_TIME | 트리거가 발생하는 시점이다. |
| EVENT_TYPE | 트리거를 발생시키는 이벤트 종류이다. |
| GRANULARITY | 트리거가 발생하는 단위이다. |
[OB18] 작업(Job)#
작업(Job) 객체 정보를 보여 준다. 이 쿼리는 Altibase 6.5.1 이상 버전에서 사용할 수 있으며, 주석이 붙은 칼럼을 삭제하면 Altibase 6.3.1에서도 사용할 수 있다.
SELECT JOB_NAME
, EXEC_QUERY PROC_NAME
, INTERVAL
, LPAD(DECODE(INTERVAL_TYPE, 'YY', 'YEARLY',
'MM', 'MONTHLY',
'DD', 'DAILY',
'HH', 'HOURLY',
'MI', 'MINUTELY'), 13) INTERVAL_TYPE
, LPAD(DECODE(STATE, 0, '-', 1, 'ING'), 5) STATE
, LPAD(EXEC_COUNT, 10) EXEC_COUNT
, LPAD(ERROR_CODE, 10) ERROR_CODE
, TO_CHAR(START_TIME, 'YYYY-MM-DD HH:MI:SS') START_TIME
, TO_CHAR(LAST_EXEC_TIME, 'YYYY-MM-DD HH:MI:SS') LAST_EXEC_TIME
, TO_CHAR(END_TIME, 'YYYY-MM-DD HH:MI:SS') END_TIME
, DECODE(IS_ENABLE, 'T', 'YES', 'F', 'NO') IN_ENABLE -- Altibase 6.3.1에서는 삭제한다.
FROM SYSTEM_.SYS_JOBS_
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| JOB_NAME | Job 객체의 이름이다. |
| PROC_NAME | Job에 등록한 프로시저 이름이다. |
| INTERVAL, INTERVAL_TYPE | 수행 주기이다. |
| STATE | Job 진행 상태이다. ING이면 작업 스케줄러가 현재 프로시저를 수행 중이다. |
| EXEC_COUNT | Job 실행 횟수이다. |
| ERROR_CODE | 마지막 Job 실행 결과이다. |
| START_TIME | Job이 처음 수행을 시작한 시각이다. |
| LAST_EXEC_TIME | Job을 가장 최근에 수행한 시각이다. |
| END_TIME | 마지막으로 수행한 Job이 종료된 시각이다. |
| IN_ENABLE | 작업 스케줄러가 Job을 실행할 수 있는 상태인지 보여 준다. |
[OB19] 데이터베이스 사용자#
데이터베이스 사용자 정보를 보여 준다.
SELECT USER_ID
, USER_NAME
, TBS.NAME 'DEFAULT_TBS'
, CREATED
FROM SYSTEM_.SYS_USERS_ U
, V$TABLESPACES TBS
WHERE U.DEFAULT_TBS_ID = TBS.ID
;
[OB20] 테이블스페이스 목록#
테이블스페이스 목록을 보여 준다.
SELECT ID 'TBS_ID'
, NAME 'TBS_NAME'
, DECODE(TYPE, 0, 'SYSTEM_TBS',
1, 'SYSTEM_TBS',
2, 'USER_MEM_TBS',
3, 'SYSTEM_TBS',
4, 'USER_DISK_TBS',
5, 'SYSTEM_TBS',
6, 'USER_DISK_TEMP',
7, 'SYSTEM_UNDO',
8, 'USER_VOL_TBS') 'TBS_TYPE'
FROM V$TABLESPACES
;
권한#
권한 정보를 확인하는 쿼리를 소개한다.
[PV01] 시스템 권한#
모든 사용자에게 부여된 시스템 권한을 보여 준다. 특정 사용자의 권한만 보려면 A.USER_NAME 조건의 주석을 해제하고 사용자 이름을 입력한다. 이 쿼리는 Altibase 4.3.9 이상 버전에서 사용할 수 있다.
SELECT A.USER_NAME GRANTEE
, C.USER_NAME GRANTOR
, REPLACE(D.PRIV_NAME, '_', ' ') PRIV_NAME
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_GRANT_SYSTEM_ B
, SYSTEM_.SYS_USERS_ C
, SYSTEM_.SYS_PRIVILEGES_ D
WHERE C.USER_NAME <> 'SYSTEM_'
AND A.USER_TYPE <> 'R' -- Altibase 6.5.1 미만 버전에서는 이 조건을 삭제한다.
AND B.GRANTEE_ID = A.USER_ID
AND B.GRANTOR_ID = C.USER_ID
AND B.PRIV_ID = D.PRIV_ID
--AND A.USER_NAME = 'user_name'
ORDER BY GRANTEE, GRANTOR
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| GRANTEE | 권한을 부여받은 사용자의 이름이다. |
| GRANTOR | 권한을 부여한 사용자의 이름이다. |
| PRIV_NAME | 시스템 권한 이름이다. |
[PV02] 객체 권한#
모든 사용자에게 부여된 객체 권한을 보여 준다. 이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있으며, 주석이 붙은 부분을 삭제하면 이전 버전에서도 사용할 수 있다.
SELECT A.USER_NAME GRANTEE
, C.USER_NAME GRANTOR
, F.USER_NAME OBJECT_OWNER
, OBJ.OBJ_NAME OBJECT_NAME
, DECODE(OBJ.OBJ_TYPE, 'T', DECODE(OBJ.OBJ_TYPE1, 'T', 'TABLE', 'V', 'VIEW'),
'S', 'SEQUENCE',
'P', 'PROCEDURE',
'Y', 'External library',
'D', 'DIRECTORY') OBJECT_TYPE
, REPLACE(D.PRIV_NAME, '_', ' ') PRIV_NAME
, DECODE(B.WITH_GRANT_OPTION, 0, 'NO', 'YES') WITH_GRANT_OPTION
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_GRANT_OBJECT_ B
, SYSTEM_.SYS_USERS_ C
, SYSTEM_.SYS_PRIVILEGES_ D
, (SELECT TABLE_NAME AS OBJ_NAME, TABLE_TYPE AS OBJ_TYPE1, 'T' AS OBJ_TYPE, TABLE_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_TABLES_ WHERE TABLE_TYPE IN ('V', 'T')
UNION
SELECT TABLE_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, TABLE_TYPE AS OBJ_TYPE, TABLE_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_TABLES_ WHERE TABLE_TYPE = 'S'
UNION
SELECT PROC_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'P' AS OBJ_TYPE, PROC_OID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_PROCEDURES_
UNION
SELECT DIRECTORY_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'D' AS OBJ_TYPE, DIRECTORY_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_DIRECTORIES_
UNION -- Altibase 6.3.1 미만 버전에서는 삭제한다.
SELECT LIBRARY_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'Y' AS OBJ_TYPE, LIBRARY_ID AS OBJ_ID, USER_ID -- Altibase 6.3.1 미만 버전에서는 삭제한다.
FROM SYSTEM_.SYS_LIBRARIES_ -- Altibase 6.3.1 미만 버전에서는 삭제한다.
) OBJ
, SYSTEM_.SYS_USERS_ F
WHERE 1=1
AND C.USER_NAME <> 'SYSTEM_'
AND A.USER_TYPE <> 'R' -- Altibase 6.5.1 미만 버전에서는 이 조건을 삭제한다.
AND B.GRANTEE_ID = A.USER_ID
AND B.GRANTOR_ID = C.USER_ID
AND B.PRIV_ID = D.PRIV_ID
AND B.OBJ_ID = OBJ.OBJ_ID
AND OBJ.OBJ_TYPE = B.OBJ_TYPE
AND OBJ.USER_ID = F.USER_ID
ORDER BY GRANTEE, GRANTOR, OBJECT_OWNER, OBJECT_NAME, PRIV_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| GRANTEE | 권한을 부여받은 사용자의 이름이다. |
| GRANTOR | 권한을 부여한 사용자의 이름이다. |
| OBJECT_OWNER | 객체 소유자 이름이다. |
| OBJECT_NAME | 객체 이름이다. |
| PRIV_NAME | 권한 종류이다. |
| WITH_GRANT_OPTION | 객체 권한을 부여받은 사용자가 다른 사용자에게 해당 권한을 다시 부여할 수 있는지 나타낸다. |
[PV03] 롤 생성 정보#
데이터베이스에 생성된 롤(role) 목록과 롤에 부여된 시스템 권한, 객체 권한을 보여 준다. 롤은 Altibase 6.5.1부터 지원하므로 이 쿼리는 Altibase 6.5.1 이상 버전에서 사용할 수 있다.
SELECT A.USER_NAME 'ROLE_NAME'
, RPAD('SYSTEM', 9) PRIV_TYPE
, '' OBJECT_NAME
, '' OBJECT_TYPE
, REPLACE(D.PRIV_NAME, '_', ' ') PRIV_NAME
, '' WITH_GRANT_OPTION
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_GRANT_SYSTEM_ B
, SYSTEM_.SYS_PRIVILEGES_ D
WHERE 1=1
AND A.USER_ID <> 0
AND A.USER_TYPE = 'R'
AND B.GRANTEE_ID = A.USER_ID
AND B.PRIV_ID = D.PRIV_ID
UNION
SELECT A.USER_NAME 'ROLE_NAME'
, RPAD('OBJECT', 9) PRIV_TYPE
, F.USER_NAME||'.'||OBJ.OBJ_NAME OBJECT_NAME
, DECODE(OBJ.OBJ_TYPE, 'T', DECODE(OBJ.OBJ_TYPE1, 'T', 'TABLE', 'V', 'VIEW'),
'S', 'SEQUENCE',
'P', 'PROCEDURE',
'Y', 'External library',
'D', 'DIRECTORY') OBJECT_TYPE
, REPLACE(D.PRIV_NAME, '_', ' ') PRIV_NAME
, DECODE(B.WITH_GRANT_OPTION, 0, 'NO', 'YES') WITH_GRANT_OPTION
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_GRANT_OBJECT_ B
, SYSTEM_.SYS_PRIVILEGES_ D
, (SELECT TABLE_NAME AS OBJ_NAME, TABLE_TYPE AS OBJ_TYPE1, 'T' AS OBJ_TYPE, TABLE_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_TABLES_ WHERE TABLE_TYPE IN ('V', 'T')
UNION
SELECT TABLE_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, TABLE_TYPE AS OBJ_TYPE, TABLE_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_TABLES_ WHERE TABLE_TYPE = 'S'
UNION
SELECT PROC_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'P' AS OBJ_TYPE, PROC_OID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_PROCEDURES_
UNION
SELECT DIRECTORY_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'D' AS OBJ_TYPE, DIRECTORY_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_DIRECTORIES_
UNION
SELECT LIBRARY_NAME AS OBJ_NAME, '' AS OBJ_TYPE1, 'Y' AS OBJ_TYPE, LIBRARY_ID AS OBJ_ID, USER_ID
FROM SYSTEM_.SYS_LIBRARIES_
) OBJ
, SYSTEM_.SYS_USERS_ F
WHERE 1=1
AND A.USER_ID <> 0
AND A.USER_TYPE = 'R'
AND B.GRANTEE_ID = A.USER_ID
AND B.PRIV_ID = D.PRIV_ID
AND B.OBJ_ID = OBJ.OBJ_ID
AND OBJ.OBJ_TYPE = B.OBJ_TYPE
AND OBJ.USER_ID = F.USER_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| ROLE_NAME | 롤의 이름이다. |
| PRIV_TYPE | 롤에 부여된 권한의 종류로, 'SYSTEM'은 시스템 권한, 'OBJECT'는 객체 권한이다. |
| OBJECT_NAME | PRIV_TYPE이 OBJECT이면 객체 이름을 '객체 소유자.객체 이름' 형식으로 보여 준다. |
| OBJECT_TYPE | PRIV_TYPE이 OBJECT이면 객체 종류를 보여 준다. |
| PRIV_NAME | 권한 이름이다. |
| WITH_GRANT_OPTION | PRIV_TYPE이 OBJECT이면 객체 권한을 부여받은 사용자가 다른 사용자에게 해당 권한을 다시 부여할 수 있는지 나타낸다. |
[PV04] 롤을 부여받은 사용자 정보#
롤을 누구에게 부여했고 누가 부여했는지 보여 준다. 이 쿼리는 Altibase 6.5.1 이상 버전에서 사용할 수 있다.
SELECT U1.USER_NAME GRANTEE
, U2.USER_NAME GRANTOR
, RU.USER_NAME ROLE_NAME
FROM SYSTEM_.SYS_USER_ROLES_ R
, SYSTEM_.SYS_USERS_ RU
, SYSTEM_.SYS_USERS_ U1
, SYSTEM_.SYS_USERS_ U2
WHERE 1=1
AND RU.USER_TYPE = 'R'
AND R.ROLE_ID <> 0
AND RU.USER_ID = R.ROLE_ID
AND R.GRANTEE_ID = U1.USER_ID
AND R.GRANTOR_ID = U2.USER_ID
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| GRANTEE | 롤을 부여받은 데이터베이스 사용자이다. |
| GRANTOR | 롤을 부여한 데이터베이스 사용자이다. |
| ROLE_NAME | 롤 이름이다. |
[PV05] 시스템 및 객체 권한 종류#
Altibase가 지원하는 시스템 권한과 객체 권한 목록을 보여 준다. 이 쿼리는 Altibase 4.3.9 이상 버전에서 사용할 수 있다.
SELECT DECODE(PRIV_TYPE, 1, 'OBJECT', 2, 'SYSTEM') PRIV_TYPE
, PRIV_NAME
FROM SYSTEM_.SYS_PRIVILEGES_
ORDER BY PRIV_TYPE, PRIV_NAME
;
제약조건과 인덱스#
제약조건과 인덱스 정보를 확인하는 쿼리를 소개한다.
[CT01] 전체 제약조건 목록#
데이터베이스에 생성된 모든 제약조건 목록을 보여 준다. 이 쿼리는 Altibase 6.3.1 이상 버전에서 사용할 수 있으며, 주석이 붙은 칼럼을 삭제하면 이전 버전에서도 사용할 수 있다.
SELECT USER_NAME
, TABLE_NAME OBJECT_NAME
, DECODE(B.TABLE_TYPE, 'T', 'TABLE', 'Q', 'QUEUE', 'V', 'VIEW', 'SEQUENCE') OBJECT_TYPE
, C.CONSTRAINT_NAME CONST_NAME
, DECODE(C.CONSTRAINT_TYPE, 0, 'FOREIGN KEY',
1, 'NOT NULL',
2, 'UNIQUE',
3, 'PRIMARY KEY',
4, 'NULL',
5, 'TIMESTAMP',
6, 'LOCAL UNIQUE',
7, 'CHECK') CONST_TYPE
, COLUMN_NAME
, CHECK_CONDITION -- Altibase 6.3.1 미만 버전에서는 삭제한다.
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, SYSTEM_.SYS_CONSTRAINTS_ C
, SYSTEM_.SYS_COLUMNS_ D
, SYSTEM_.SYS_CONSTRAINT_COLUMNS_ E
WHERE A.USER_ID=C.USER_ID
AND B.TABLE_ID = C.TABLE_ID
AND A.USER_ID = D.USER_ID
AND A.USER_ID = E.USER_ID
AND B.TABLE_ID = D.TABLE_ID
AND B.TABLE_ID = E.TABLE_ID
AND C.CONSTRAINT_ID = E.CONSTRAINT_ID
AND D.COLUMN_ID = E.COLUMN_ID
AND A.USER_NAME <> 'SYSTEM_'
ORDER BY USER_NAME, OBJECT_NAME, CONST_TYPE
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| OBJECT_TYPE | 객체 유형으로, TABLE(T), VIEW(V), SEQUENCE(S), QUEUE(Q)가 있다. |
| CONST_TYPE | 제약조건 유형으로, FOREIGN KEY(0), NOT NULL(1), UNIQUE(2), PRIMARY KEY(3), NULL(4), TIMESTAMP(5), LOCAL UNIQUE(6), CHECK(7)이 있다. |
| CHECK_CONDITION | CHECK 제약조건을 지정할 때 정의한 무결성 규칙이다. Altibase 6.3.1부터 제공한다. |
[CT02] PK, FK, UNIQUE 관련 제약조건 및 테이블, 인덱스 목록#
Primary Key, Foreign Key, Unique 제약조건의 정보를 보여 준다. 이 쿼리는 Altibase 4.3.9 이상 버전에서 사용할 수 있다.
SELECT A.USER_NAME
, B.TABLE_NAME
, DECODE(C.CONSTRAINT_TYPE, 0, 'FK', 2, 'UNIQUE', 3, 'PK', 4, 'NULL') CONST_TYPE
, C.CONSTRAINT_NAME CONST_NAME
, DECODE(D.INDEX_NAME, C.CONSTRAINT_NAME, NULL, INDEX_NAME) INDEX_NAME
, (SELECT TABLE_NAME
FROM SYSTEM_.SYS_TABLES_
WHERE TABLE_ID = C.REFERENCED_TABLE_ID) R_TABLE
, (SELECT INDEX_NAME
FROM SYSTEM_.SYS_INDICES_
WHERE INDEX_ID = C.REFERENCED_INDEX_ID) R_INDEX
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, SYSTEM_.SYS_CONSTRAINTS_ C LEFT OUTER JOIN SYSTEM_.SYS_INDICES_ D ON C.INDEX_ID = D.INDEX_ID
WHERE C.TABLE_ID = B.TABLE_ID
AND A.USER_NAME <> 'SYSTEM_'
AND C.USER_ID = A.USER_ID
AND C.CONSTRAINT_TYPE IN (3, 0, 2, 6) -- PK, FK, UNIQUE, LOCAL UNIQUE
ORDER BY TABLE_NAME, CONST_TYPE
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| R_TABLE | 제약조건이 FK이면 참조 대상 테이블의 이름이다. |
| R_INDEX | 제약조건이 FK이면 참조 대상 인덱스의 이름이다. |
[CT03] 복합 인덱스 칼럼 구성 목록#
복합 인덱스의 칼럼 구성 정보를 보여 준다.
SELECT D.USER_NAME
, C.TABLE_NAME
, B.INDEX_NAME
, E.COLUMN_NAME
, A.INDEX_COL_ORDER COL_ORDER
, DECODE(A.SORT_ORDER, 'A', 'ASC', 'D', 'DESC') SORT
FROM SYSTEM_.SYS_INDEX_COLUMNS_ A
, SYSTEM_.SYS_INDICES_ B
, SYSTEM_.SYS_TABLES_ C
, SYSTEM_.SYS_USERS_ D
, SYSTEM_.SYS_COLUMNS_ E
WHERE D.USER_NAME <> 'SYSTEM_'
AND C.TABLE_TYPE = 'T'
AND A.INDEX_ID = B.INDEX_ID
AND A.TABLE_ID = C.TABLE_ID
AND A.USER_ID = D.USER_ID
AND A.COLUMN_ID = E.COLUMN_ID
ORDER BY USER_NAME, TABLE_NAME, INDEX_NAME, COL_ORDER
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| COL_ORDER | 인덱스를 구성하는 칼럼의 순서로, 0부터 시작한다. |
| SORT | 인덱스 칼럼의 정렬 방식으로, ASC(A) 또는 DESC(D)이다. |
[CT04] 인덱스 정보 요약#
인덱스 정보를 보여 준다.
SELECT A.USER_NAME
, C.INDEX_NAME
, C.INDEX_ID
, B.TABLE_NAME
, NVL(D.NAME, 'SYS_TBS_MEMORY') TBS_NAME
, C.IS_UNIQUE
, C.COLUMN_CNT
FROM SYSTEM_.SYS_USERS_ A
, SYSTEM_.SYS_TABLES_ B
, SYSTEM_.SYS_INDICES_ C LEFT OUTER JOIN V$TABLESPACES D ON C.TBS_ID = D.ID
WHERE A.USER_NAME <> 'SYSTEM_'
AND B.TABLE_TYPE = 'T'
AND C.TABLE_ID = B.TABLE_ID
AND C.USER_ID = A.USER_ID
ORDER BY B.TABLE_NAME, C.INDEX_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| TBS_NAME | 인덱스가 저장된 테이블스페이스의 이름이다. Altibase 4와 호환되도록 테이블스페이스가 없는 인덱스는 메모리 테이블스페이스(SYS_TBS_MEMORY)로 간주한다. |
| IS_UNIQUE | 인덱스의 유니크 여부로, TRUE(T) 또는 FALSE(F)이다. |
| COLUMN_CNT | 인덱스를 구성하는 칼럼의 개수이다. |
이중화#
이중화 정보를 확인하는 쿼리를 소개한다.
[RP01] 이중화 Sender 정보#
Sender의 정보를 보여 준다. 이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있으며, REPL_MODE 칼럼을 삭제하면 Altibase 4에서도 사용할 수 있다.
SELECT REP_NAME
, PEER_IP REMOTE_IP
, PEER_PORT REMOTE_REP_PORT
, DECODE(STATUS, 0, 'STOP', 1, 'RUN', 2, 'RETRY') AS STATUS
, REPL_MODE -- Altibase 4에서는 삭제한다.
, DECODE(NET_ERROR_FLAG, 0, 'OK', 'ERROR') AS NETWORK
, XSN
FROM V$REPSENDER
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| REP_NAME | 이중화 객체의 이름이다. |
| REMOTE_IP | 이중화 대상인 원격 서버의 IP 주소이다. |
| REMOTE_REP_PORT | 이중화 대상인 원격 서버의 이중화 포트 번호로, 원격 서버의 프로퍼티로 정한다. |
| STATUS | Sender의 현재 상태로, 정상이면 RUN(1)이다. STOP(0), RUN(1), RETRY(2)가 있다. |
| REPL_MODE | Sender의 현재 이중화 모드이다. Altibase 5부터 제공한다. |
| NETWORK | 네트워크 오류 여부로, 정상이면 OK(0)이다. OK(0), ERROR(1)이 있다. |
| XSN | Sender가 마지막으로 전송한 SN(Serial Number, 로그 일련번호)으로, V$REPGAP의 REP_SN과 같다. |
[RP02] 이중화 Receiver 정보#
Receiver의 정보를 보여 준다.
SELECT REP_NAME
, PEER_IP REMOTE_IP
, PEER_PORT REMOTE_REP_PORT
, APPLY_XSN
FROM V$REPRECEIVER
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| REMOTE_IP | 이중화 주체인 원격 서버의 IP 주소이다. |
| REMOTE_REP_PORT | 이중화 주체인 원격 서버의 Sender가 접속한 포트 번호이다. 정해진 값이 아니므로 접속할 때마다 다르다. |
| APPLY_XSN | Receiver가 현재 반영 중인 원격 서버의 SN이다. |
[RP03] 이중화 갭#
이중화 갭 정보를 보여 준다. 이 쿼리는 Altibase 5.3.3 이상 버전에서 사용할 수 있으며, START_FLAG 칼럼을 삭제하면 이전 버전에서도 사용할 수 있다.
SELECT REP_NAME
, REP_SN
, REP_LAST_SN
, REP_GAP
, READ_FILE_NO
, START_FLAG -- Altibase 5.3.3 미만 버전에서는 삭제한다.
FROM V$REPGAP
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| REP_SN | Sender가 마지막으로 전송한 SN으로, V$REPSENDER의 XSN과 같다. |
| REP_LAST_SN | 지역 서버의 트랜잭션이 가장 최근에 기록한 로그의 SN이다. |
| REP_GAP | REP_LAST_SN과 REP_SN의 간격(REP_LAST_SN - REP_SN)으로, 동기화되지 않은 정도를 나타낸다. |
| READ_FILE_NO | Sender가 이중화를 위해 마지막으로 접근한 로그 파일 번호이다. Sender는 메모리에 있는 이중화 전용 로그 버퍼를 읽을 때 이 값을 갱신하지 않으므로, 이중화 갭이 없어도 과거 로그 파일 번호가 나타날 수 있다. 따라서 이 값은 이중화 갭이 있을 때만 의미가 있다. |
| START_FLAG | 이중화의 구동 상태로, 일반적으로 0이다. NORMAL(0), QUICK(1), SYNC(2), SYNC_ONLY(3), SYNC RUN(4), SYNC END(5), RECOVERY(6), OFFLINE(7)이 있다. Altibase 5.3.3부터 제공한다. |
[RP04] 이중화 전체 현황#
SELECT A.REPLICATION_NAME REP_NAME
, D.HOST_IP REMOTE_IP
, NVL(TO_CHAR(E.REP_GAP), '-') AS REP_GAP
, A.XSN RESTART_XSN
, DECODE(B.PEER_PORT, NULL, 'OFF', 'ON') AS SENDER
, DECODE(C.PEER_PORT, NULL, 'OFF', 'ON') AS RECEIVER
FROM SYSTEM_.SYS_REPL_HOSTS_ D
, SYSTEM_.SYS_REPLICATIONS_ A
LEFT OUTER JOIN V$REPSENDER B ON A.REPLICATION_NAME = B.REP_NAME
LEFT OUTER JOIN V$REPRECEIVER C ON A.REPLICATION_NAME = C.REP_NAME
LEFT OUTER JOIN (SELECT REP_NAME, MAX(REP_GAP) REP_GAP
FROM V$REPGAP
GROUP BY REP_NAME) E ON A.REPLICATION_NAME = E.REP_NAME
WHERE A.REPLICATION_NAME = D.REPLICATION_NAME
ORDER BY REP_NAME
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| RESTART_XSN | 이중화 대상인 원격 서버가 반영한 SN으로, 이중화를 다시 시작할 때 재전송 기점이 된다. |
| SENDER | Sender의 작동 여부이다. |
| RECEIVER | Receiver의 작동 여부이다. |
[RP05] 이중화하지 못해 누적된 로그 파일 측정#
이 쿼리는 Altibase 5 이상 버전에서 사용할 수 있다.
SELECT CASE2((BUFFER_MIN_SN < READ_SN),
'REP BUFFER '||ROUND((BUFFER_MAX_SN-READ_SN)/(BUFFER_MAX_SN-BUFFER_MIN_SN)*100, 2)||' % LEFT ',
(SELECT TO_CHAR(CUR_WRITE_LF_NO - READ_FILE_NO) FROM V$LFG, V$REPGAP)
) LOGFILE_FOR_REP
FROM V$REPLOGBUFFER
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| LOGFILE_FOR_REP | Sender가 이중화 전용 로그 버퍼를 읽는 중이면 이중화 전용 로그 버퍼에서 전송해야 할 로그의 양을 백분율로 보여 준다. Sender가 로그 파일을 직접 읽는 중이면 이중화해야 할 로그 파일의 개수를 보여 주므로, 이를 MB로 환산해 볼 수 있다. 값이 백분율로만 나타나면 Sender가 이중화 전용 로그 버퍼만으로 이중화하고 있으므로 양호한 상태이다. 매우 빠르게 전송할 때는 순간적으로 음수가 나올 수 있으나 무시해도 된다. 반면 로그 파일 개수가 자주 나타나면 이중화 전용 로그 버퍼의 크기를 정하는 REPLICATION_LOG_BUFFER_SIZE 프로퍼티 값을 기본값인 30MB보다 크게 늘린다. 또는 Sender를 위해 미리 메모리에 캐시할 로그 파일의 개수를 정하는 REPLICATION_PREFETCH_LOGFILE_COUNT 프로퍼티 값을 늘린다. |
[RP06] 이중화 대상 테이블 목록#
이중화 객체에 등록된 테이블을 보여 준다.
SELECT REPLICATION_NAME REP_NAME
, LOCAL_USER_NAME||'.'||LOCAL_TABLE_NAME LOCAL_TBL
, REMOTE_USER_NAME||'.'||REMOTE_TABLE_NAME REMOTE_TBL
FROM SYSTEM_.SYS_REPL_ITEMS_
ORDER BY 1, 2
;
주요 칼럼의 의미는 다음과 같다.
| 칼럼 | 설명 |
|---|---|
| LOCAL_TBL | 지역 서버의 이중화 대상 테이블로, '사용자 이름.테이블 이름' 형식으로 보여 준다. |
| REMOTE_TBL | 원격 서버의 이중화 대상 테이블로, '사용자 이름.테이블 이름' 형식으로 보여 준다. |