PL / SQL 집합 방법

PL / SQL 에 서 는 자주 사용 되 는 세 가지 집합 배열, 포 함 된 표, 길 어 지 는 배열 을 제공 합 니 다. 이 몇 가지 집합 유형 에서 요소 의 조작 에 대해 PL / SQL 은 해당 하 는 함수 나 과정 을 제공 하여 배열 의 요소 나 아래 표 시 를 조작 합 니 다.이 함수 나 과정 을 집합 방법 이 라 고 한다.하나의 집합 방법 은 집합 에 내장 되 어 있 고 집합 을 조작 할 수 있 는 함수 나 과정 으로 점 표 지 를 통 해 호출 할 수 있다.본 고 는 주로 이런 방법 들 을 어떻게 조작 하 는 지 를 묘사한다.1. 집합 유형 이 제공 하 는 방법 과 호출 방식 1. 집합 하 는 방법 과 호출 방식    EXISTS        함수 EXISTS (n) 는 n 번 째 요소 가 존재 하 는 경우 TRUE 로 돌아 갑 니 다. 그렇지 않 으 면 FALSE 로 돌아 갑 니 다.            보통 EXISTS 와 DELETE 를 사용 하여 내장 시 계 를 유지 합 니 다.그 중에서 도 EXISTS 는 존재 하지 않 는 요 소 를 인용 하여 이상 이 발생 하지 않도록 방지 할 수 있다.        아래 표 시 를 넘 으 면 EXISTS 는 SUBSCRIPT 가 아 닌 FALSE 로 돌아 갑 니 다.OUTSIDE_LIMIT 이상.    COUNT        COUNT 는 집합 에 포 함 된 요소 개 수 를 되 돌려 줄 수 있 으 며 크기 가 불확실 한 경우 COUNT 에 매우 유용 합 니 다.        for 순환 의 상한 선 같은 정수 표현 식 을 사용 할 수 있 는 모든 곳 에서 COUNT 함 수 를 사용 할 수 있 습 니 다.        요소 개 수 를 계산 할 때 삭 제 된 요 소 는 count 에 의 해 집계 되 지 않 습 니 다.        길 어 지 는 배열 에 있어 서 COUNT 값 은 LAST 값 과 같다.        내장 표 의 경우 정상 적 인 경우 COUNT 값 은 LAST 값 과 같 습 니 다.단, 끼 워 넣 은 테이블 에서 원 소 를 삭제 하면 COUNT 값 은 LAST 값 보다 작 습 니 다.                LIMIT        집합 최대 용량 검사        플러그 인 테이블 과 관련 그룹 모두 상계 제한 이 없 기 때문에 LIMIT 는 항상 NULL 로 돌아 갑 니 다.        길 어 지 는 배열 에 대해 LIMIT 는 수용 할 수 있 는 요소 의 최대 값 을 되 돌려 줍 니 다. 이 값 은 길 어 지 는 배열 성명 에서 지정 되 며 TRIM 과 EXTEND 방법 으로 조정 할 수 있 습 니 다.                    FIRST,LAST        FIRST 와 LAST 는 집합 에서 첫 번 째 요소 와 마지막 요소 가 집합 에서 표시 한 아래 색인 값 을 되 돌려 줍 니 다.        VARCHAR 2 형식 을 키 로 사용 하 는 관련 배열 의 경우 각각 가장 낮은 키 와 가장 높 은 키 값 을 되 돌려 줍 니 다.키 값 의 높낮이 순 서 는 문자열 에 있 는 문자 의 바 이 너 리 값 을 기반 으로 합 니 다.        단, 인자 NLS 를 초기 화하 면COMP 가 ANSI 로 설정 되면 키 의 높낮이 순 서 는 초기 화 매개 변수 NLSSORT 가 영향 을 미 쳤 습 니 다.        빈 집합 FIRST 와 LAST 방법 은 항상 NULL 로 돌아 갑 니 다.하나의 요소 의 집합 만 있 고 FIRST 와 LAST 는 같은 색인 값 을 되 돌려 줍 니 다.        길 어 지 는 배열 에 대해 서 는 FIRST 항 등 이 1 이 고, LAST 항 등 이 COUNT 이다.        플러그 인 테이블 에 대해 FIRST 는 보통 1 을 되 돌려 주 며, 첫 번 째 요 소 를 삭제 하면 FIRST 의 값 이 1 보다 크 고, 중간 요 소 를 삭제 하면 LAST 가 COUNT 보다 크다.        요 소 를 옮 겨 다 닐 때 FIRST 와 LAST 는 삭 제 된 요 소 를 무시 합 니 다.    PRIOR,NEXT,        PRIOR (n) 은 집합 에서 n 으로 인 식 된 요소 의 전구 색인 값 을 되 돌려 줍 니 다.NEXT (n) 는 집합 에서 n 으로 인 식 된 요소 의 후속 색인 값 을 되 돌려 줍 니 다.        n 이 전구 나 후계 가 없 으 면 PRIOR (n) 또는 NEXT (n) 는 NULL 로 돌아 갑 니 다.        VARCHAR 2 를 키 로 사용 하 는 관련 배열 에 있어 서 각각 가장 낮은 키 와 가장 높 은 키 를 되 돌려 줍 니 다.키 값 의 높낮이 순 서 는 문자열 에 있 는 문자 의 바 이 너 리 값 을 기반 으로 합 니 다.        PRIOR 과 NEXT 는 집합의 한 끝 에서 집합의 다른 한 끝, 즉 마지막 원소 의 next 는 집합의 first 를 가리 키 지 않 는 다.        요 소 를 옮 겨 다 닐 때 PRIOR 과 NEXT 는 삭 제 된 요 소 를 무시 합 니 다. 즉, prior (3) 이전의 2 가 삭제 되면 1 을 가리 키 고 1 도 삭제 되면 null 로 돌아 갑 니 다.    EXTEND        플러그 인 테이블 이나 길 어 지 는 그룹의 용량 을 확대 하 는 데 사용 되 며, 이 방법 은 콤비네이션 그룹 에 사용 할 수 없습니다.        EXTEND 는 세 가지 형식 이 있어 요.            EXTEND 는 집합 끝 에 빈 요 소 를 추가 합 니 다.            EXTEND (n) 집합 끝 에 n 개의 빈 요 소 를 추가 합 니 다.            EXTEND (n, i) 는 i 번 째 요 소 를 n 부 복사 하여 집합 끝 에 추가 합 니 다.        내장 표 나 길 어 지 는 배열 에 NOT NULL 제약 을 추가 한 후 EXTEND 의 두 가지 형식 을 사용 할 수 없습니다.        EXTEND 는 삭 제 된 요소 도 포 함 된 집합 내부 크기 를 작 동 합 니 다.따라서 EXTEND 는 원소 개 수 를 계산 할 때 삭 제 된 원소 도 고려한다.        DELETE 방법 으로 작 동 하 는 요소 에 대해 PL / SQL 은 자리 표시 자 를 유지 하고 나중에 다시 사용 할 수 있 습 니 다.                    TRIM        집합 끝 에서 (TRIM) 또는 지정 한 수량의 TRIM (n) 요 소 를 삭제 합 니 다. PL / SQL 은 TRIM 에서 떨 어 진 요소 에 대해 자리 표시 자 를 유지 하지 않 습 니 다.        n 값 이 너무 크 면 TRIM (n) 은 SUBSCRIPT 를 던 집 니 다.BEYOND_COUNT 이상.        보통 TRIM 과 DELETE 방법 을 동시에 사용 하지 않 는 다.내장 시 계 를 정수 그룹 으로 사용 할 수 있 으 며, DELETE 방법 만 사용 하거나 스 택 으로 사용 할 수 있 으 며, TRIM 과 EXTEND 방법 만 사용 할 수 있 습 니 다.            DELETE         집합 에 있 는 모든 또는 지정 한 범위 의 요 소 를 삭제 합 니 다. 보통 다음 호출 방식 이 있 습 니 다.        DELETE 는 집합 에 있 는 모든 요 소 를 삭제 합 니 다.        DELETE (n) 는 숫자 를 메 인 키 로 하 는 관련 배열 이나 내장 표 에서 n 번 째 요 소 를 삭제 합 니 다.            관련 배열 에 문자열 키 가 있 으 면 키 를 눌 러 야 할 요소 가 삭 제 됩 니 다.n 이 비어 있 으 면 DELETE (n) 는 아무것도 하지 않 습 니 다.        DELETE (m, n) 는 관련 배열 이나 내장 표 에서 색인 범위 m 에서 n 까지 의 모든 요 소 를 삭제 합 니 다.            만약 m 값 이 n 보다 크 거나 m 와 n 중 하나 가 비어 있다 면 DELETE (m, n) 는 아무것도 하지 않 습 니 다.            PL / SQL 은 DELETE 방식 으로 삭 제 된 요 소 를 위해 자리 표시 자 를 유지 하고 나중에 삭 제 된 요소 에 값 을 다시 부여 할 수 있 습 니 다.            주, delete 방식 으로 길 어 지 는 배열 의 요 소 를 삭제 할 수 없습니다.                                호출 방식:            collection_name.method_name[(parameters)]  2. 집합 방법 주의사항    집합 하 는 방법 은 SQL 구문 에서 사용 할 수 없습니다.    EXTEND 와 TRIM 방법 은 관련 배열 에 사용 할 수 없습니다.    EXISTS, COUNT, LIMIT, FIRST, LAST, PRIOR 와 NEXT 는 함수 입 니 다.EXTEND, TRIM 과 DELETE 는 과정 이다.    EXISTS, PRIOR, NEXT, TRIM, EXTEND 와 DELETE 에 대응 하 는 매개 변 수 는 집합 적 인 아래 표 시 된 색인 으로 보통 정수 이지 만 관련 배열 에 있어 서도 문자열 일 수 있 습 니 다.    EXISTS 만 빈 집합 에 사용 할 수 있 습 니 다. 빈 집합 에서 다른 방법 을 호출 하면 PL / SQL 은 이상 COLLECTION 을 던 집 니 다.IS_NULL。 2. 각 방법 을 종합 적 으로 보 여 준다.
-->  1
DECLARE
   output           VARCHAR2( 300 );

   TYPE index_by_type IS TABLE OF VARCHAR2( 10 )
                            INDEX BY BINARY_INTEGER;

   index_by_table   index_by_type;

   TYPE nested_type IS TABLE OF NUMBER;

   nested_table     nested_type                           -->                
                       := nested_type( 10,20,30,40 ,50 ,60 ,70,80 ,90,100 );
BEGIN
   -- Populate index by table
   FOR i IN 1 .. 10                                       -->           
   LOOP
      index_by_table( i ) := 'Value_' || i;
   END LOOP;

   DBMS_OUTPUT.
    put_line( '--------------------------- Before deleted -----------------------------------------' );

   FOR i IN index_by_table.FIRST .. index_by_table.LAST   -->   first,last,                      
   LOOP
      output      := output || NVL( TO_CHAR( index_by_table( i ) ), 'NULL' ) || '  ';
   END LOOP;

   DBMS_OUTPUT.put_line( 'Element of Index_by_table are: ' || output );
   output      := '';

   FOR i IN 1 .. nested_table.COUNT                      -->   count,                     
   LOOP
      output      := output || NVL( TO_CHAR( nested_table( i ) ), 'NULL' ) || '  ';
   END LOOP;

   DBMS_OUTPUT.put_line( 'Element of nested_table are: ' || output );

   IF index_by_table.EXISTS( 3 ) THEN       -->EXISTS           3       
      DBMS_OUTPUT.put_line( 'index_by_table(3) exists and the value is ' || index_by_table( 3 ) );
   END IF;

   -- delete 10th element from a collection
   nested_table.delete( 10 );
   -- delete elements 1 through 3 from a collection
   nested_table.delete( 1, 3 );
   index_by_table.delete( 10 );
   DBMS_OUTPUT.put_line( 'nested_table.COUNT = ' || nested_table.COUNT );
   DBMS_OUTPUT.put_line( 'index_by_table.COUNT = ' || index_by_table.COUNT );
   DBMS_OUTPUT.put_line( 'nested_table.FIRST = ' || nested_table.FIRST );
   DBMS_OUTPUT.put_line( 'nested_table.LAST = ' || nested_table.LAST );
   DBMS_OUTPUT.put_line( 'index_by_table.FIRST = ' || index_by_table.FIRST );
   DBMS_OUTPUT.put_line( 'index_by_table.LAST = ' || index_by_table.LAST );
   DBMS_OUTPUT.put_line( 'nested_table.PRIOR(2) = ' || nested_table.PRIOR( 2 ) );
   DBMS_OUTPUT.put_line( 'nested_table.NEXT(2) = ' || nested_table.NEXT( 2 ) );
   DBMS_OUTPUT.put_line( 'index_by_table.PRIOR(2) = ' || index_by_table.PRIOR( 2 ) );
   DBMS_OUTPUT.put_line( 'index_by_table.NEXT(2) = ' || index_by_table.NEXT( 2 ) );
   -- Trim last two elements
   nested_table.TRIM( 2 );
   -- Trim last element
   nested_table.TRIM;
   DBMS_OUTPUT.put_line( 'nested_table.LAST = ' || nested_table.LAST );
   DBMS_OUTPUT.put_line( '--------------------------- After deleted -----------------------------------------' );

 output:='';
   FOR i IN index_by_table.FIRST .. index_by_table.LAST     -->                  
   LOOP
      output      := output || NVL( TO_CHAR( index_by_table( i ) ), 'NULL' ) || '  ';
   END LOOP;

   DBMS_OUTPUT.put_line( 'Element of Index_by_table are: ' || output );
   output      := '';

 output:='';
   FOR i IN  nested_table.FIRST .. nested_table.LAST       -->                 
   LOOP
      output      := output || NVL( TO_CHAR( nested_table( i ) ), 'NULL' ) || '  ';
   END LOOP;

   DBMS_OUTPUT.put_line( 'Element of nested_table are: ' || output );
END;

--------------------------- Before deleted -----------------------------------------
Element of Index_by_table are: Value_1  Value_2  Value_3  Value_4  Value_5  Value_6  Value_7  Value_8  Value_9  Value_10
Element of nested_table are: 10  20  30  40  50  60  70  80  90  100
index_by_table(3) exists and the value is Value_3
nested_table.COUNT = 6      -->        delete,               1  3   ,      count   6
index_by_table.COUNT = 9    -->               ,       count   9
nested_table.FIRST = 4      -->       1  3   ,   first  4
nested_table.LAST = 9       -->            ,  last  9
index_by_table.FIRST = 1
index_by_table.LAST = 9
nested_table.PRIOR(2) =     -->    PRIOR(2), 2       (   1),  1-3    , 1        ,  NULL
nested_table.NEXT(2) = 4    -->   2       ,     3,  3   ,  3   ,  4
index_by_table.PRIOR(2) = 1
index_by_table.NEXT(2) = 3  
nested_table.LAST = 7      -->nested_table.TRIM(2) nested_table.TRIM     3       , LAST 7。
--------------------------- After deleted -----------------------------------------
Element of Index_by_table are: Value_1  Value_2  Value_3  Value_4  Value_5  Value_6  Value_7  Value_8  Value_9
Element of nested_table are: 40  50  60  70

PL/SQL procedure successfully completed.
----------------------------------------------------------------------------------------------------------------------------		
-->  2
DECLARE
   TYPE varray_type IS VARRAY(10) OF NUMBER;
   varray varray_type := varray_type(1, 2, 3, 4, 5, 6);
   PROCEDURE print_numlist( the_list varray_type ) IS
      output   VARCHAR2( 128 );
   BEGIN
      FOR i IN the_list.FIRST .. the_list.LAST
      LOOP
         output      := output || NVL( TO_CHAR( the_list( i ) ), 'NULL' ) || ' ';
      END LOOP;

      DBMS_OUTPUT.put_line( output );
   END;
BEGIN
   print_numlist( varray );
   DBMS_OUTPUT.put_line( 'varray.COUNT = ' || varray.COUNT );
   DBMS_OUTPUT.put_line( 'varray.LIMIT = ' || varray.LIMIT );
   DBMS_OUTPUT.put_line( 'varray.FIRST = ' || varray.FIRST );
   DBMS_OUTPUT.put_line( 'varray.LAST = ' || varray.LAST );
   DBMS_OUTPUT.put_line( 'The maximum number you can use with ' || 'varray.EXTEND() is ' || ( varray.LIMIT - varray.COUNT ) );
   varray.EXTEND( 2, 4 );        -->  4       2 ,       
   DBMS_OUTPUT.put_line( 'varray.LAST = ' || varray.LAST );
   DBMS_OUTPUT.put_line( 'varray(' || varray.LAST || ') = ' || varray( varray.LAST ) );
   print_numlist( varray );
   -- Trim last two elements
   varray.TRIM( 2 );
   DBMS_OUTPUT.put_line( 'varray.LAST = ' || varray.LAST );
END;

1 2 3 4 5 6               -->  varray      
varray.COUNT = 6
varray.LIMIT = 10         -->limit             
varray.FIRST = 1
varray.LAST = 6
The maximum number you can use with varray.EXTEND() is 4   -->    extend   ,      4   
varray.LAST = 8          --> extend  last     8
varray(8) = 4            --> 8       4
1 2 3 4 5 6 4 4          -->  varray      
varray.LAST = 6          -->     varray.TRIM( 2 ),  last    6

PL/SQL procedure successfully completed.

-->Author : Robinson Cheng
-->Blog   : http://blog.csdn.net/robinson_0612

3. 더 많은 참고
PL / SQL 집합 초기 화 및 할당
PL / SQL 연합 배열 과 내장 표 PL / SQL 이 길 어 지 는 배열 PL / SQL -- > PL / SQL 기록
SQL 튜 닝 절차
고 효율 SQL 구문 필 살기
부모 커서, 하위 커서 및 공유 커서
바 인 딩 변수 및 장단 점
dbms_xplan 의 displaycursor 함수 사용
dbms_xplan display 함수 사용
실행 계획 의 필드 별 모듈 설명
EXPLAIN PLAN 을 사용 하여 SQL 문장 실행 계획 가 져 오기
AUTORCE 기능 사용 하기
함수 가 색인 열 을 무효 화 합 니 다.
Oracle 바 인 딩 변수 탐색
Oracle 자체 적응 공유 커서

좋은 웹페이지 즐겨찾기