콘텐츠로 이동
목차

Altibase 모니터링 쿼리 가이드#

개요#

이 문서는 Altibase를 모니터링할 때 알아야 할 메타 테이블과 성능 뷰를 소개하고, 모니터링 요소별 쿼리 예시를 제시한다. 먼저 모니터링의 분류와 데이터 딕셔너리를 설명하고, 이어서 주요 메타 테이블과 성능 뷰의 관계를 ERD로 보여 준다. 마지막으로 세션, 쿼리, 트랜잭션, 테이블스페이스, 객체, 이중화 등 모니터링 요소별 쿼리를 제공한다.

이 문서는 이름만으로 의미를 알 수 있는 칼럼과 앞에서 이미 설명한 칼럼의 설명은 생략한다. 메타 테이블과 성능 뷰의 자세한 설명은 Altibase 매뉴얼의 General Reference를 함께 참고한다.

이 문서는 Altibase 4 이상 버전을 기준으로 한다.

Info

이 문서와 관련된 오류 및 개선사항은 기술지원포털 또는 기술지원센터로 문의주시기 바랍니다.

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 원격 서버의 이중화 대상 테이블로, '사용자 이름.테이블 이름' 형식으로 보여 준다.