KR20080086875A - 데이터베이스를 관리하기 위한 컴퓨터 구현 방법, 및데이터베이스에 지향되는 트랜잭션들을 관리하기 위한컴퓨터 구현 방법 - Google Patents

Abstract

델타 페이저(delta pager)는 원자, 격리된 트랜잭션들(atomic, isolated transactions)을 이용하여 데이터베이스를 유지한다. 트랜잭션이 데이터베이스에 변경을 행하려고 시도할 경우, 델타 페이저는 그 변경들을 기입 버퍼에 저장하고, 개입 트랜잭션들(intervening transactions)이 상기 트랜잭션이 의지하는 데이터베이스의 상태를 사실상 또는 실질상 변경하지 않는 경우 그 변경들을 적용한다. 델타 페이저는 기입 버퍼들을 데이터베이스의 현 상태와 결합하여 데이터베이스의 상태를 나타내는 새로운 데이터 구조를 형성함으로써 트랜잭션을 커밋하도록 변경들을 적용한다. 델타 페이저는 데이터베이스의 선택된 상태들을 보전하기 위해 고려하는 스냅숏들을 조건으로 하여, 효율성을 유지하기 위해 기입 버퍼들을 합체시킨다. 델타 페이저는 선택된 데이터를 영속성 저장소(durable store)에 이동시킴으로써 데이터베이스의 선택된 부분들을 영속성 있게 만든다. 델타 페이저는 또한 영속성 저장소와 현 트랜잭션들 사이에 캐시 개체들을 제공하여 데이터에의 효율적인 액세스를 촉진한다.

데이터베이스, 델타 페이저, 트랜잭션, 버퍼, 스냅숏

Description

데이터베이스를 관리하기 위한 컴퓨터 구현 방법, 및 데이터베이스에 지향되는 트랜잭션들을 관리하기 위한 컴퓨터 구현 방법{MANAGING STATES WITH DELTA PAGER}

데이터베이스 트랜잭션을 수행하는 데 있어서 중요한 관심사는 데이터베이스 무결성(database integrity)이다. 데이터베이스 무결성을 보전하기 위해서는, 트랜잭션들이 원자성(atomicity) 및 격리(isolation) 등의 요건들을 준수하도록 보장하는 것이 중요하다. 원자성 요건은, 불완전한 트랜잭션이 데이터베이스에 적용되지 않도록, 트랜잭션의 태스크들 전부가 수행되거나 또는 어느 것도 수행되지 않을 것을 요구한다. 격리 요건은, 어떤 트랜잭션도 다른 트랜잭션의 중간 상태에 액세스하거나 그것을 방해하지 않도록, 트랜잭션들이 다른 트랜잭션들과는 별개로 처리될 것을 지시한다. 원자성 및 격리 요건들을 준수하는 것은 트랜잭션들이 서로 그리고 전체로서의 데이터베이스에 오류를 일으키지 못하게 한다.

네트워크화된 시스템들에서는, 다수의 사용자들 및 다수의 애플리케이션들이 동시에 동일한 데이터에 대해 트랜잭션들을 수행하려고 시도할 수 있다. 독립 실행형 시스템에서도, 다수의 애플리케이션들이 동일한 데이터에 대해 트랜잭션들을 수행하려고 시도할 수 있고, 아마도 각 애플리케이션의 다중 처리 스레드들이 서로 경합할 수 있다. 트랜잭션들이 충돌하거나 일치하지 않는 변경들을 데이터베이스 에 적용할 수 있는 모든 상황들을 피하는 것은 고사하고, 예견하는 것도 어렵기 때문에, 데이터베이스 무결성을 유지하는 것은 중대한 도전 과제이다.

데이터베이스 무결성을 보전하는 한 가지 방법은 현 트랜잭션에 의해 사용되는 데이터베이스의 일부분에 잠금을 설정(place a lock)하는 것이다. 데이터베이스의 일부분에 잠금을 설정하는 것은 현 트랜잭션이 완료될 때까지 다른 트랜잭션들이 데이터를 판독하거나 덮어쓰기(overwrite)하지 못하게 한다. 다른 트랜잭션들이 데이터베이스의 일부분으로부터 판독하지 못하게 하는 것은 다른 트랜잭션들이 현 트랜잭션이 변경할 수 있는 값들에 기초한 결과들에 도달하지 못하도록 한다. 그에 대응하여, 다른 트랜잭션들이 데이터베이스의 일부분을 덮어쓰기하지 못하게 하는 것은 다른 트랜잭션들이 현 트랜잭션에 영향을 미치지 못하도록 한다.

그러나, 데이터베이스의 일부분에 잠금을 설정하는 것은 데이터 무결성을 보전하는 데 도움이 될 수는 있지만, 그것은 또한 상쇄하는 비용을 초래할 수도 있다. 다수의 트랜잭션들이 액세스하려고 시도하는 데이터베이스의 일부분에 잠금을 설정하는 것은 트랜잭션들의 상당한 적체(backlog)를 유발할 수 있다. 대기하는 트랜잭션들의 일부 또는 전부가 데이터베이스의 현 상태에 어떤 변경도 행하지 않을 수도 있고, 또는 현 트랜잭션이 사용하는 특정 값들로부터 판독하거나, 그 값들에 기입하거나, 또는 그 값들을 변경하지 않을 수도 있다. 그럼에도 불구하고, 데이터베이스의 일부분에 잠금을 설정하는 것은, 비록 데이터베이스의 액세스를 더디게 할지라도, 데이터베이스의 무결성을 보전할 것이다.

잠금의 한 형태는 임대(lease)이다. 아파트, 건물, 차, 및 장비의 임대의 경우에서와 마찬가지로, 임대는 한정된 시간 기간 동안의 배타적인 허가(exclusive grant)이다. 따라서, 하나의 트랜잭션에 선택된 데이터에 대한 임대가 허가될 경우, 그 트랜잭션에는 한정된 시간 기간 동안 그 선택된 데이터에의 배타적인 액세스가 제공된다. 데이터에의 배타적인 액세스를 시간 기간으로 한정함으로써, 트랜잭션이 완료될 때 트랜잭션이 데이터를 해제(release)하지 못하거나, 또는 트랜잭션이 실행되는 시스템이 폭주(crash)할 경우, 데이터는 잠금해제(unlock)될 것이고 따라서 다른 트랜잭션들은 그 데이터에 액세스하기 위해 무기한 기다릴 필요가 없을 것이다. 통상적으로 선택된 데이터를 기다리고 있는 각 트랜잭션은 그 데이터에 대하여 이전에 큐(queue)된 모든 트랜잭션들이 그들의 데이터의 사용을 완료하거나, 또는 각 트랜잭션에 할당된 임대가 만료될 때까지 기다려야 할 것이다.

다수의 트랜잭션들이 임대된 데이터에의 액세스를 기다릴 때 잠재적으로 상당한 지연이 있을 수 있다. 또한, 데이터의 임대를 제어하는 시스템이 데이터에 액세스하려는 시도들에 병목 상태를 일으킬 수 있다. 임대를 제어하는 시스템은, 데이터 액세스에 대한 제어의 단일 포인트로서, 임대 요구들에 응답하려는 시도에서 트랜잭션 지연들을 일으킬 수 있다. 더욱이, 시스템은 동일한 선택된 데이터에 대하여 다수의 요구를 수신할 수 있기 때문에, 이들 다수의 그리고 잠재적으로 반복된 요구들을 처리하는 것은 컴퓨팅 사이클들을 낭비할 것이고, 그 결과 동일한 데이터 또는 임의의 다른 데이터를 추구하는 트랜잭션들에 추가 지연을 초래한다.

<발명의 요약>

델타 페이저(delta pager)는 원자, 격리된 트랜잭션들(atomic, isolated transactions)을 이용하여 데이터베이스를 유지한다. 트랜잭션이 데이터베이스에 변경을 행하려고 시도할 경우, 델타 페이저는 그 변경들을 기입 버퍼에 저장하고, 개입 트랜잭션들(intervening transactions)이 상기 트랜잭션이 의지하는 데이터베이스의 상태를 사실상 또는 실질상 변경하지 않는 경우 그 변경들을 적용한다. 델타 페이저는 기입 버퍼들을 데이터베이스의 현 상태와 결합하여 데이터베이스의 상태를 나타내는 새로운 데이터 구조를 형성함으로써 트랜잭션을 커밋하도록 변경들을 적용한다. 델타 페이저는 데이터베이스의 선택된 상태들을 보전하기 위해 고려하는 스냅숏들을 조건으로 하여, 효율성을 유지하기 위해 기입 버퍼들을 합체시킨다. 델타 페이저는 선택된 데이터를 영속성 저장소(durable store)에 이동시킴으로써 데이터베이스의 선택된 부분들을 영속성 있게 만든다. 델타 페이저는 또한 영속성 저장소와 현 트랜잭션들 사이에 캐시 개체들을 제공하여 데이터에의 효율적인 액세스를 촉진한다.

이 요약은 아래 상세한 설명에서 더 설명되는 개념들 중 선택된 것을 단순한 형태로 소개하기 위해 제공된다. 이 요약은 청구된 내용의 중요한 특징들 또는 필수적인 특징들을 식별하기 위해 의도된 것도 아니고, 청구된 내용의 범위를 판정하는 데 도움을 주기 위해 의도된 것도 아니다.

상세한 설명은 첨부 도면들을 참조하여 설명된다. 도면에서, 3자리 숫자 참조 번호의 가장 왼쪽 숫자 또는 4자리 숫자 참조 번호의 왼쪽 2자리 숫자는 그 참조 번호가 처음 나오는 도면을 식별한다. 상이한 도면들에서 동일한 참조 번호를 사용하는 것은 유사하거나 동일한 항목들(items)을 나타낸다.

도 1은 데이터베이스의 초기, 현 상태를 예시한다.

도 2는 데이터베이스로 지향된 제1 트랜잭션을 예시한다.

도 3-6은 버퍼들을 이용하여 데이터베이스에 대해 트랜잭션이 실행되고 커밋되는 것을 예시한다.

도 7-11은 누적 기입 버퍼들(cumulative write buffers)을 이용하여 트랜잭션이 실행되는 것을 예시한다.

도 12는 기입 버퍼들을 이용하여 트랜잭션을 실행하는 양태(mode)를 예시한다.

도 13은 단일 기입 버퍼를 이용하여 트랜잭션이 실행되는 것을 예시한다.

도 14는 단일 기입 버퍼를 이용하여 트랜잭션을 실행하는 양태를 예시한다.

도 15는 제1 트랜잭션이 개입 트랜잭션으로서 실행되는 동안 데이터베이스에 대하여 제2 트랜잭션이 실행되는 것을 예시한다.

도 16-20은 개입 트랜잭션의 결과로서 현 트랜잭션의 커밋(commitment) 및 중단(abortion)을 예시한다.

도 21은 개입 트랜잭션의 결과로서 트랜잭션을 언제 커밋 또는 중단할지를 판정하는 양태를 예시한다.

도 22-27은 판독 및 기입 버퍼들을 이용하여 데이터베이스에 대해 잠재적으로 경합하는 트랜잭션들이 실행되고 커밋되는 것을 예시한다.

도 28은 판독 및 기입 버퍼들을 이용하여 트랜잭션을 실행하는 양태를 예시 한다.

도 29는 판독 및 기입 버퍼들을 이용하여 개입 트랜잭션의 결과로서 트랜잭션을 언제 커밋 또는 중단할지를 판정하는 양태를 예시한다.

도 30-31은 버퍼들의 합체를 예시한다.

도 32-34는 데이터베이스의 선택된 상태를 후속 상태들로 합체되는 것으로부터 보전하기 위해 스냅숏 개체를 이용하는 것을 예시한다.

도 35는 하나 이상의 선택된 상태들을 보전하면서 버퍼들을 합체시키는 양태를 예시한다.

도 36-37은 버퍼가 영속성 있게 되는 것을 예시한다.

도 38은 개체들을 영속성 있게 만드는 양태를 예시한다.

도 39는 캐시 개체의 이용을 예시한다.

도 40은 캐시 개체를 생성 및 유지하는 양태를 예시한다.

도 41은 전술한 개체들의 컬렉션을 예시한다.

도 42는 전술한 데이터베이스 트랜잭션들 및 동작들을 수행하기에 적합한 전형적인 동작 환경을 예시한다.

개관( Overview )

"델타 페이저(delta pager)"라는 용어는 데이터베이스의 무결성을 유지하고 데이터베이스의 선택된 상태들을 보전하면서 데이터베이스에 대한 변경들을 처리하기 위한 방법들 및 시스템들의 실시예들을 기술한다. 인지된 개체들 간의 포인터들의 불변성(immutability)을 고려함으로써, 델타 페이저는 데이터베이스의 상태들의 무결성을 보전하면서 또한 효율성을 유지한다.

일 양태에서, 델타 페이저는 현 상태 포인터를 이용하여 데이터베이스에 저장된 모든 데이터의 완전한 매핑을 포함하는 데이터베이스의 현 상태를 추적함으로써 트랜잭션들을 관리한다. 완전한 매핑(complete mapping)에서는, 데이터베이스에 대하여 정의된 각 어드레스 또는 어드레스의 표현에 대하여, 데이터 값 또는 널 값이 있을 것이다. 부분적 매핑(partial mapping)은 트랜잭션이 개시된 때 존재하는 데이터베이스의 현 상태에 트랜잭션이 적용하려고 시도하는 변경들을 저장하기 위해 델타 페이저가 이용하는 하나 이상의 개체들을 포함할 수 있다. 만일 데이터베이스에 대해 트랜잭션이 커밋되면, 부분적 매핑은 데이터베이스의 원래의 현 상태에 추가되어 새로운 현 상태를 형성한다. 새로이 적용된 부분적 매핑을 통하여 새로운 현 상태가 액세스되는 경우, 부분적 매핑에서의 어드레스들에의 값들의 할당들은 원 상태에서의 것들을 대체하고, 그에 의해 데이터베이스의 원 상태에서의 데이터 값들 효율적으로 덮어쓰기 하거나 변경한다.

이 설명에서 사용되는 용어를 분명히 하고 구별하기 위하여, 데이터베이스의 매핑(mapping)은 어드레스 값들의 데이터 값들에의 할당을 나타낸다. 데이터베이스의 완전한 매핑(complete mapping)은 데이터베이스 내의 모든 어드레스들의 그 어드레스들에 저장된 데이터 값들(또는 널 값들)에의 할당들의 완전한 세트를 나타낸다. 부분적 매핑(partial mapping)은 트랜잭션이 데이터를 기입하려고 시도하는 어드레스들, 및 트랜잭션이 어드레스들에 기입하려고 시도하는 데이터 값들을 포함하여, 트랜잭션이 데이터베이스에 대해 행하는 또는 행하려고 시도하는 변경들 또는 덮어쓰기들의 세트를 나타낸다. 데이터베이스에 대해 트랜잭션이 커밋되는 경우, 부분적 매핑은 이전의 완전한 매핑에 추가되고, 그 결과 데이터베이스의 현 매핑이 업데이트될 수 있다. 따라서, 데이터베이스의 현, 완전한 매핑은 부분적 매핑들의 시리즈(a series of partial mappings)를 포함할 수 있고, 나중에 추가된 부분적 매핑들은 이전의 부분적 매핑들에 포함된 어드레스들의 할당들을 덮어쓰기하거나 변경할 수 있다.

데이터베이스의 상태(state)는 데이터베이스의 매핑이 저장되어 있는 메모리, 디스크, 또는 대용량 저장소에 저장된 개체들의 컬렉션을 나타낸다. 상태 내의 개체들은 트랜잭션이 데이터베이스에 기입하려고 시도하는 변경들을 저장하기 위해 트랜잭션들에 대하여 델타 페이저가 생성하는 버퍼들은 물론, 그 버퍼들이 수집(collect)될 수 있는 다른 개체들을 포함한다. 버퍼들, 다른 개체들, 및 이들 개체들이 어떻게 결합되고, 합체되고, 다른 식으로 조작되는지에 대하여 아래에서 상세히 설명된다. 데이터베이스의 현 상태는 데이터베이스의 현, 완전한 매핑을 나타내는 개체들을 포함한다. 아래 설명되는 바와 같이, 델타 페이저는 또한 트랜잭션이 개시될 때 존재하는 데이터베이스의 상태와 같은 다른 상태들을 유지한다. 델타 페이저는 이 상태를 추적하여 데이터베이스에 대해 트랜잭션이 커밋되어야 할지를 판정한다. 델타 페이저는 또한 나중에 사용하기 위해 그 상태들, 및 그 상태들이 나타내는 데이터베이스의 매핑들을 보전하기 위해 선택된 상태들을 유지한다.

각 트랜잭션이 개시할 때, 델타 페이저는 트랜잭션이 개시된 때 존재하는 데이터베이스의 상태에 기초하여 트랜잭션이 실행되게 한다. 그 후 트랜잭션은 기입 버퍼와 같은 적어도 하나의 개체를 생성하고, 그 기입 버퍼를 트랜잭션이 개시된 때 존재하는 데이터베이스의 상태로 포인팅한다. 델타 페이저는 일련의 버퍼들을 이용할 수 있고, 각 버퍼는 트랜잭션이 데이터베이스에 적용하려고 시도하는 단일 변경을 저장하고, 각 버퍼는 데이터베이스의 상태를 보전하기 위해 선행 버퍼로 포인팅한다. 대안적으로, 델타 페이저는 트랜잭션이 개시된 때의 데이터베이스의 현 상태로 포인팅하는 누적 기입 버퍼에 트랜잭션이 행하려고 시도하는 모든 변경들을 저장할 수 있다. 트랜잭션이 개시된 때의 상태로 포인팅하는 버퍼들 또는 다른 개체들은 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경들의 부분적 매핑을 나타낸다.

만일 델타 페이저가 하나 이상의 개입 트랜잭션들이 그것이 현 트랜잭션들을 적용하지 못하게 한다는 어떤 지시도 찾아내지 못하면, 델타 페이저는 데이터베이스의 현 상태를 추적하기 위해 델타 포인터가 이용하는 현 상태 포인터를 트랜잭션에 대하여 생성된 최후 버퍼, 즉 유일한 버퍼로 포인팅하도록 변경함으로써 트랜잭션을 커밋한다. 현 상태 포인터를 버퍼로 포인팅하도록 변경하는 것은, 데이터베이스의 새로운 업데이트된 상태를 생성하여, 잠재적으로 데이터베이스의 완전한 매핑에서의 데이터 값들을 변경한다.

델타 페이저는 트랜잭션들을 처리하기 위해 판독 버퍼들 및 기입 버퍼들을 이용할 수 있다. 판독 버퍼들은 트랜잭션이 액세스하는 데이터를 추적한다. 현 트랜잭션이 완전한 경우, 델타 페이저는 트랜잭션을 커밋할지를 판정하기 위해 판독 버퍼를 이용한다. 판독 버퍼가 현 트랜잭션이 개입 트랜잭션에 의해 덮어쓰기되거나 변경된 데이터를 판독한 것을 보여주면 델타 페이저는 트랜잭션을 중단할 수 있다.

델타 페이저가 데이터베이스에 대해 복수의 변경들을 커밋한 후, 델타 페이저는 효율성을 위하여 데이터베이스의 현 상태에서 버퍼들 또는 다른 개체들을 합체시킬 수 있다. 델타 페이저는 하나의 부분적 매핑에서의 복수의 개체들을 또 다른 부분적 매핑에서의 개체들과 합체시킬 수 있다. 이 2개의 부분적 매핑들 중 새로운 것에서의 어드레스들의 할당들이 오래된 부분적 매핑에 포함된 할당들에 추가되거나 그것들을 대체할 것이다. 합체의 결과로, 메모리 개체들 또는 영속성 개체들을 포함하는 하나 이상의 합체된 개체들이 생길 수 있고, 또는 델타 페이저는 버퍼들에 저장된 변경들을 데이터베이스의 원 상태에 적용함으로써 버퍼들을 합체시킬 수 있다. 델타 페이저는 선택된 상태들의 보전을 가능케 하는 스냅숏 포인터들을 제공한다. 스냅숏 포인터와 연관된 어떤 상태도 스냅숏 포인터에 의해 보전된 상태에 행해진 변경들을 나타내는 버퍼들과 합체되지 않을 것이다.

델타 페이저는 데이터베이스 및 데이터베이스에 행해진 변경들이 영속성 있게 되는 것을 가능케 한다. 델타 페이저는 데이터베이스의 현 상태를 유지하기 위해 이용되는 하나 이상의 개체들을 영속성 비휘발성 저장소에 복사할 수 있다. 델타 페이저는 또한 델타 페이저가 영속성 있게 만들기기 위해 비휘발성 저장소로 이동시킨 현 상태의 부분들을 포함하여, 대용량 저장 매체에 저장된 데이터베이스의 현 상태의 일부분에의 보다 신속한 액세스를 제공하는 캐시 개체들을 제공한다. 델타 페이저는 이 캐시 개체들을 이용하여 데이터베이스의 상태에 널 데이터 범위들(null data ranges)을 저장하여 범위 쿼리(range queries)를 용이하게 한다.

기입 버퍼를 이용한 트랜잭션 처리

도 1은 데이터베이스의 현 상태(100)를 예시한다. 현 상태(100)는 데이터베이스의 예시적인 원 상태(110)를 포함한다. 데이터베이스는 휘발성 메모리 또는 비휘발성 저장소에 존재할 수 있다. 델타 페이저는 도 1에서 원 상태(110)만을 포함하는 현 상태로 포인팅하기 위해 현 상태 포인터(120)를 이용한다.

원 상태(110)는 각각이 현재 널 값을 저장하는 5개의 레코드, 레코드 0(130), 레코드 1(140), 레코드 2(150), 레코드 3(160), 및 레코드 4(170)를 유지하는 개체이다. 원 상태에 널 값들이 실제로 저장될 필요는 없다는 것에 유의한다. 또한, 원 상태(110)는 트랜잭션들이 변경들을 적용할 수 있는, 널(null) 및 널이 아닌(non-null) 값들을 포함하는, 임의의 초기 상태를 포함할 수 있다.

도 2는 예시적인 트랜잭션으로, 복수의 명령들(210-270)을 포함하는 트랜잭션 1(200)을 예시한다. 그 명령들 중, 명령 1(220), "x = Read(3)"과 같은, 어떤 명령은 데이터베이스로부터 데이터를 판독하려고 시도한다. 명령 3(240), "Write(2,x)"와 같은, 다른 명령들은 데이터베이스 내의 어드레스에 값을 할당하거나 재할당하게 될 변경을 데이터베이스에 적용하려고 시도한다.

도 3은 델타 페이저가 데이터베이스에 대하여, 트랜잭션 1(200)과 같은 트랜잭션을 개시하는 하나의 양태를 예시한다. 트랜잭션 1(200)은 트랜잭션 시작 명령인 trans_start(210)로 시작한다. 트랜잭션 1(200)의 개시 후에, 현 상태 포인터(120)는 트랜잭션이 개시된 때의 데이터베이스의 상태인 원 상태(110)로 계속해서 포인팅한다. 델타 페이저는 제1 기입 버퍼(310)를 생성하고, 거기에 델타 페이저는 트랜잭션 1(200)이 적용하려고 시도하는 변경을 저장할 것이다. 델타 페이저는 기입 버퍼(310)를 현 상태 포인터(120)에 의해 지시된, 트랜잭션 1(200)이 개시된 때의 상태로 포인팅한다. 델타 페이저는 또한 트랜잭션 포인터(320)를 생성하고, 트랜잭션 포인터(320)를 제1 기입 버퍼(310)로 포인팅하고, 제1 기입 버퍼(310)는 현 상태로 포인팅한다.

도 4-6은 델타 페이저가 어떻게 트랜잭션 1(200)을 처리하는지를 예시한다. 도 2를 참조하면, 명령 1(220), "x=Read(3)"은 어드레스 3으로부터 널인 x의 현 값을 판독한다. 명령 2(230), "x=x+1"은 x의 값을 1만큼 증가시키고, 이 경우, x의 값을 1로 변경한다. 명령 3(240), "Write(2,x)"는 컴퓨팅 시스템에게 x의 값을 어드레스 2에 기입하도록 지시한다.

델타 페이저는 원 상태(110)에서의 어드레스 2에 값 1을 기입하지 않는다. 대신, 도 4에 도시된 바와 같이, 델타 페이저는 제2 기입 버퍼(410)를 생성한다. 제2 기입 버퍼(410)는 제1 기입 버퍼(310)로 포인팅하고, 델타 페이저는 트랜잭션 1(200)이 트랜잭션이 개시된 때 데이터베이스의 상태를 어떻게 변경할지를 나타내는 데이터베이스의 부분적 매핑을 유지하기 위해 트랜잭션 포인터(320)를 제2 기입 버퍼(410)로 포인팅하도록 스위칭한다. 델타 페이저는 값 1을 어드레스 2에 기입하는 변경을 제2 기입 버퍼(410)에 저장한다.

도 5는 트랜잭션 1(200)이 데이터베이스에 행하려고 시도하는 제2 변경에 대한 델타 페이저의 응답을 예시한다. 명령 4(250), "Write(4,"DOG")"는 컴퓨팅 시스템에게 문자열 "DOG"를 어드레스 4에 저장하도록 지시한다. 다시, 원 상태(110)에 변경을 기입하는 대신, 델타 페이저는 제2 기입 버퍼(410)로 포인팅하는 제 3 기입 버퍼(510)를 생성한다. 델타 페이저는 또한 트랜잭션 1(200)이 데이터베이스를 변경할 것이므로 데이터베이스의 상태를 보전하기 위해 트랜잭션 포인터(320)를 제3 기입 버퍼(510)로 포인팅하도록 변경하고, 문자열 "DOG"를 제3 기입 버퍼(510)에 저장한다. 따라서, 트랜잭션 포인터(320)로부터 판독하면, 트랜잭션 1(200)에 대한 데이터베이스의 부분적 매핑은 어드레스 2는 값 1을 저장하고, 어드레스 4는 문자열 "DOG"를 저장하는 변경들을 포함한다. 그러나, 트랜잭션은 원 상태(110)도, 현 상태 포인터(120)에 의해 지시된 현 상태도 변경하지 않았다.

도 6은 델타 페이저가 어떻게 데이터베이스에 트랜잭션 1(200)을 커밋하는지를 예시한다. 트랜잭션 포인터(320)는, 기입 버퍼들(510, 410, 및 310)을 통하여, 현 상태 포인터(120)가 포인팅하는 동일한 상태로 포인팅하기 때문에, 델타 페이저는 트랜잭션 1(200)이 데이터베이스에 커밋되는 것을 막기 위해 어떤 개입 트랜잭션도 데이터베이스의 현 상태를 변경하지 않았다고 판정한다. 따라서, 델타 페이저는 기입 버퍼들(310, 410 및 510)에 의해 변경된 원 상태(110)를 포함하는, 트랜잭션 1(200)에 대하여 생성된 부분적 매핑으로 포인팅하도록 현 상태 포인터(120)를 변경함으로써 데이터베이스에 트랜잭션 1(200)을 커밋한다. 따라서, 델타 페이저는 트랜잭션 1(200)에 의해 추가된 최후 기입 버퍼인 제3 기입 버퍼(510)로 포인팅하도록 현 상태 포인터(120)를 변경한다. 현 상태 포인터(120)는 이제 기입 버퍼들(310, 410 및 510)에 저장된 변경들에 의해 업데이트된 원 상태(110)를 포함하는 데이터베이스의 업데이트된 상태로 포인팅한다.

도 6의 현 상태를 이용하여, 트랜잭션이 데이터베이스에 액세스하는 경우, 델타 페이저는, 현 상태 포인터(120)의 의해 식별되는, 트랜잭션이 개시되는 때에 존재하는 데이터베이스의 상태를 이용한다. 현 상태를 이용하여, 만일 트랜잭션이 어드레스 4의 콘텐츠를 식별하려고 시도하면, 버퍼(510)에서 그것은 문자열 "DOG"를 발견할 것이다. 한편, 만일 트랜잭션이 어드레스 2의 콘텐츠를 추구하면, 그것은 버퍼(510)에서 그것을 발견하지 못할 것이다. 따라서, 트랜잭션은 버퍼(410)로 진행할 것이고, 거기서 트랜잭션은 값 1을 발견할 것이다. 만일 트랜잭션이 다른 값을 추구하면, 도 6의 예에서, 트랜잭션은 원 상태(110)가 다른 어드레스들에 대하여 널 값들만을 포함한다는 것을 발견할 때까지 모든 버퍼들에 액세스할 것이다. 따라서, 델타 페이저는 데이터베이스의 현 상태에 버퍼들 또는 다른 개체들을 추가함으로써 데이터를 변경한다.

델타 페이저의 불변(invariant)은 그것이 생성하는 포인터들 각각의 불변성(immutability)을 고려한다는 점이다. 불변성 불변(immutability invariant)은 각 개체가 의존하는, 따라서 그것이 포인팅하는 상태는 포인터가 해당 개체로 포인팅하는 한은 결코 변경되지 않는다는 것을 고수한다. 예를 들면, 제1 기입 버퍼(310)는 데이터베이스의 원 상태(110)로 포인팅한다. 트랜잭션 1(200)이 데이터베이스에 적용하는 후속 변경들에 관계없이, 제1 기입 버퍼(310)는 항상 원 상태(110)만을 포함하는 데이터베이스의 상태로 포인팅한다. 유사하게, 제2 기입 버퍼(410)는 제1 기입 버퍼(310)로 포인팅한다. 제2 기입 버퍼(410)는 또한 원 상태(110)를 변경하지 않는 기입 버퍼(310) 및 원 상태(110)를 포함하는 데이터베이스의 불변 상태로 포인팅한다. 제3 기입 버퍼(51D)는 제2 기입 버퍼(410)로 포인팅하고, 따라서, 제2 기입 버퍼(410)에 의해 변경된 원 상태(110)를 포함하는, 데이터베이스의 그 자신의 부분적 매핑으로 포인팅한다. 이들 포인터들의 불변성은 아래에서 설명되는 이점들을 갖는다.

누적 기입 버퍼들 및 재기입 단일 기입 버퍼들

방금 설명한 양태에서, 델타 페이저는 트랜잭션을 개시하고 또한 트랜잭션이 데이터베이스에 적용하려고 시도하는 각 변경을 저장하기 위해 새로운 기입 버퍼를 생성한다. 대안적으로, 델타 페이저는 누적 버퍼들과 같은 상이한 유형의 개체들을 이용할 수도 있고, 또는 델타 페이저는 하나 이상의 변경들을 저장하기 위해 현존하는 버퍼를 덮어쓰기할 수도 있다.

도 7은 델터 페이저가 누적 기입 버퍼들을 이용하여 트랜잭션을 처리하는 것을 예시한다. 도 3의 예에서와 같이, 델타 페이저는 현 상태 포인터(120)에 의해 지시된 바와 같이, 트랜잭션이 개시되었을 때 존재하는 현 상태로 포인팅하는 제1 누적 버퍼(710)를 생성함으로써 트랜잭션 1(200)을 개시한다. 델타 페이저는 다시, 트랜잭션 1(200)에 의해 데이터베이스가 변경될 것이므로 데이터베이스의 부분적 매핑을 유지하기 위해 트랜잭션 포인터(320)를 생성하고 그것을 가장 최근에 생성된 기입 버퍼로 포인팅한다.

도 8은 델타 페이저가 제1 누적 버퍼(710)로 포인팅하는 제2 누적 버퍼(810)를 추가함으로써 계속해서 트랜잭션을 처리하는 것을 예시한다. 델타 페이저는 트랜잭션 포인터(320)를 가장 최근에 생성된 기입 버퍼인 제2 누적 버퍼(810)로 포인팅한다. 델타 페이저는 트랜잭션 1(200)이, 어드레스 2의 값을 1로 설정하는, 데이터베이스에 적용하려고 시도하는 변경을 제2 누적 버퍼(810)에 저장한다. 트랜잭션 1(200)이 그때까지 하나의 변경만을 시도하였기 때문에 제2 누적 버퍼(810)는 누적인 것으로 보이지 않는다.

도 9는 델타 페이저가 제2 누적 버퍼(810)로 포인팅하는 제3 누적 버퍼(910)를 추가함으로써 계속해서 트랜잭션 1(200)을 처리하는 것을 예시한다. 델타 페이저는 트랜잭션 포인터(320)를 가장 최근에 생성된 기입 버퍼인 제2 누적 버퍼(910)로 포인팅한다. 델타 페이저는 이제 트랜잭션 1(200)이, 어드레스 2의 값을 1로 설정하고, 문자열 "DOG"를 어드레스 4에 저장하는, 데이터베이스에 적용하려고 시도하는 두 개의 변경들 모두를 저장한다.

도 10 및 11은 델타 페이저가 누적 기입 버퍼들을 이용하는 양태의 이점을 예시한다. 도 10은, 제2 누적 버퍼(910)에 저장된 트랜잭션 1(200)에 의해 추구되는 모든 변경들을 이용하여, 트랜잭션 1(200)이 데이터베이스에 적용할 모든 변경들의 부분적 매핑이 단일 개체인 누적 기입 버퍼(910)에 포함되는 것을 예시한다. 도 10의 예에서와 같이, 부분적 매핑은 누적 버퍼들(710 및 810)이 생략되더라도 보전된다.

불변성 불변에 따라서, 어떤 트랜잭션도 트랜잭션의 중간 상태를 방해하거나 그것에 액세스할 수 없고, 따라서, 트랜잭션 포인터(320)에 의해 지시된 상태의 무결성을 유지하기 위해 기입 버퍼들(710 및 810)이 보전될 필요는 없다. 그 결과, 누적 기입 버퍼들(710 및 810)이 저장하는 변경들이 가장 최근에 생성된 누적 버퍼(910)에도 저장된 후에는 그것들을 유지할 필요가 없다.

따라서, 도 11이 예시하는 바와 같이, 델타 페이저는 각 새로운 누적 버퍼를 생성하고 그것에 기입하므로, 델타 페이저는 이전의 버퍼들을 버릴 수 있다. 제1 단계(phase)(1100)는 어드레스 2의 값을 1로 설정하는, 제1 변경이 제2 누적 버퍼(810)에 기입된 후의 트랜잭션 1(200)의 현 상태를 보여준다. 제2 누적 버퍼(810)는 제1 기입 버퍼(710)에 저장된 어떤 변경이든 포함하기 때문에, 제2 단계(1110)에서, 델타 페이저는 제2 누적 버퍼(810)를 제1 누적 버퍼(710)가 포인팅했던 상태로 포인팅하고, 트랜잭션 포인터(320)에 의해 지시된 상태를 변경하지 않고 제1 누적 버퍼(710) 및 그것의 포인터를 해제할 수 있다. 트랜잭션 포인터(320)가 포인팅하는 상태는 보다 짧은데, 그 이유는 그것이 제2 누적 버퍼(810)에 저장된 동일 데이터의 서브세트만을 포함하는 버퍼를 통과하지 않기 때문이다. 제3 단계(1120)에서, 델타 페이저는 제1 누적 버퍼(710)를 저장하기 위해 사용된 메모리를 해제하여, 다른 용도를 위해 메모리를 절약할 수 있다. 만일 델타 페이저가 트랜잭션 1(200)의 다음 변경을 저장하기 위해 도 11에 도시된 것과 유사한 단계들을 적용한다면, 그 결과는 도 10에 예시된 것과 동일할 것이다.

도 12는 트랜잭션들을 처리하기 위해 델타 페이저가 이용하는 양태를 예시한다. 순서도(1200)는 블록 1202가 트랜잭션을 수신할 때 시작한다. 블록 1204는 트랜잭션이 데이터베이스에 적용하려고 시도하는 임의의 변경들로 포인팅할 트랜잭션 포인터를 생성한다. 블록 1206은 제1 기입 버퍼를 생성하고 그 버퍼를 트랜잭션이 수신된 때 존재하는 현 상태로 포인팅한다. 블록 1208은 트랜잭션 포인터를 제1 기입 버퍼로 포인팅하고, 제1 기입 버퍼는 트랜잭션이 개시된 때의 현 상태로 포인팅한다.

블록 1210은, 트랜잭션이, 예를 들어, 데이터베이스로부터 데이터를 판독만 하는 대신, 데이터베이스에 변경을 적용하려고 시도하는지를 판정한다. 만일 그렇다면, 블록 1212는 추가 기입 버퍼를 생성하고 그것을 이전에 생성된 버퍼로 포인팅한다. 추가 기입 버퍼들은 단일 기입 버퍼들 또는 누적 기입 버퍼들일 수 있다. 만일 누적 기입 버퍼들이 이용된다면, 하나의 양태에서, 블록 1212는 도 11을 참조하여 설명한 바와 같이 추가 누적 버퍼를 이전의 버퍼가 포인팅했던 상태로 포인팅하고, 이전의 버퍼를 해제한다.

블록 1214는 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경을 추가 기입 버퍼에 저장한다. 블록 1216은 트랜잭션 포인터를 추가 기입 버퍼로 포인팅한다. 블록 1218은 트랜잭션이 데이터베이스에 임의의 추가 변경을 적용하려고 시도하는지를 판정한다. 만일 그렇다면, 순서도(1200)는 블록 1212로 루프(loop)하고, 블록 1212는 추가 버퍼를 생성한다. 한편, 만일 블록 1218이 트랜잭션이 어떤 추가 변경도 적용하려고 시도하지 않는다고 판정하면, 뒤의 섹션에서 설명되는 바와 같이, 블록 1220은 변경들을 커밋하려고 시도할 것이다. 블록 1224는 또 다른 트랜잭션의 수신을 기다린다.

한편, 만일 블록 1210이 트랜잭션이 데이터베이스에 어떤 변경도 적용하려고 시도하지 않았다고 판정하면, 블록 1222는 제1 기입 버퍼 및 트랜잭션 포인터를 해제한다. 그 이유는 그것들이 필요하지 않기 때문이다. 블록 1224는 다시 또 다른 트랜잭션의 수신을 기다린다.

일련의 누적 버퍼들을 이용하는 대신, 델타 페이저는 또한 도 13에 예시된 바와 같이, 단일의, 재기입 가능한 기입 버퍼를 이용할 수도 있다. 제1 단계(1300)에서, 델타 페이저는 트랜잭션을 수신하고 단일 기입 버퍼(1310)를 생성하고 그것을 현 상태로 포인팅한다. 그 후 델타 페이저는 스위칭 트랜잭션 포인터(1320)를 생성하고 그것을 단일 기입 버퍼(1310)로 포인팅한다. 스위칭 포인터(1320)는 후술되는 바와 같이 델타 페이저에서의 포인터들의 불변성을 보전한다. 이런 식으로 버퍼를 덮어쓰기 또는 재기입하는 것은 델타 페이저가 변경들 각각을 저장하기 위해 다수의 버퍼들을 이용하는 대신 트랜잭션이 적용하려고 시도하는 변경들을 저장하기 위해 단일의 누적 버퍼를 이용하는 것에 의해 인지되는 불변성 불변을 보전한다.

단일 기입 버퍼(1310)를 이용하는 제2 단계(1330)에서, 델타 페이저는 스위칭 포인터(1320)를 단일 기입 버퍼(1310)로부터 다른 데로 포인팅하고, 트랜잭션에 의해 지시된 변경 또는 추가 변경으로 단일 기입 버퍼를 업데이트한다. 전술한 바와 같이, 델타 페이저는 모든 포인터들의 불변성을 보전한다. 따라서, 기술적으로, 만일 단일 기입 버퍼(1310)에 변경을 기입할 때 스위칭 포인터가 계속해서 단일 기입 버퍼(1310)로 포인팅하면, 불변성 불변은 침해될 것이다: 스위칭 포인터에 의해 포인팅된 상태는 변화하는 것으로 보일 것이다. 따라서, 일 양태에서, 델타 페이저는 그것이 단일 기입 버퍼(1310)로부터 다른 데로 포인팅할 수 있는 스위칭 포인터(1320)를 이용한다.

제3 단계(1340)에서, 일단 델타 페이저가 단일 기입 버퍼를 업데이트하면, 델타 페이저는 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경들의 부분적 매핑을 유지하기 위해 스위칭 포인터(1320)를 다시 단일 기입 버퍼(1310)로 포인팅한다. 제4 단계(1350)에서, 델타 페이저는 한번 더 스위칭 포인터(1320)를 단일 기입 버퍼(1310)로부터 다른 데로 포인팅하고, 트랜잭션에 의해 지시된 또 다른 변경을 추가하도록 단일 기입 버퍼를 업데이트한다. 제5 단계(1360)에서, 일단 델타 페이저가 추가 변경을 단일 기입 버퍼에 추가하면, 델타 페이저는 부분적 매핑을 유지하기 위해 다시 스위칭 포인터(1320)를 단일 기입 버퍼(1310)로 포인팅한다.

델타 페이저는 글자 뜻대로 실제로 버퍼(1310)로부터 다른 데로 포인팅되는 스위칭 포인터(1320)를 이용할 필요는 없다는 것에 유의한다. 불변성 불변이 논리적으로 보전되는 것을 예시하기 위해, 델타 페이저는 스위칭 포인터(1320)에 의해 지시된 재기입 가능한 버퍼들을 이용하는 것으로 기술된다. 대안적으로, 만일 재기입이 원자적으로 일어나서 재기입이 일어나는 동안 시스템의 어떤 부분도 포인터를 역참조(dereference)하지 않으면, 불변이 여전히 유효하게 보전되기 때문에, 통상의 트랜잭션 포인터(320)가 대신 이용될 수 있다: 포인터는 아무도 그 값을 관찰하지 않으면 포인터가 아니다. 그러므로 이 한정된 경우에, 델타 페이저는 적소 재기입(rewriting-in-place)을 이용한다. 그 이유는 그것이 불변성 불변을 보전하기 때문이다.

도 14는 델타 페이저가 단일 기입 버퍼를 이용하여 트랜잭션들을 처리하기 위해 이용하는 도 13에 도시된 양태를 예시한다. 순서도(1400)는 블록 1402가 트랜잭션을 수신할 때 시작한다. 블록 1404는 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경들의 부분적 매핑을 지시할 스위칭 포인터를 생성한다. 블록 1406은 단일 기입 버퍼를 생성하고 그 버퍼를 트랜잭션이 수신된 때의 현 상태로 포인팅한다. 블록 1408은 트랜잭션이 데이터베이스에 적용하려고 시도하는 부분적 매핑을 지시하기 위해 스위칭 포인터를 단일 기입 버퍼로 포인팅한다.

블록 1410은 트랜잭션이 데이터베이스에 변경을 적용하려고 시도하는지를 판정한다. 만일 그렇다면, 블록 1412는 스위칭 포인터를 단일 기입 버퍼로부터 다른 데로 포인팅한다. 블록 1414는 변경을 단일 기입 버퍼에 저장한다. 도 13에 예시된 바와 같이, 단일 기입 버퍼는 누적이고, 따라서, 복수의 변경들이 단일 기입 버퍼에 추가될 수 있다. 블록 1416은 스위칭 포인터를 다시 단일 기입 버퍼로 포인팅한다.

블록 1418은 트랜잭션이 데이터베이스에 임의의 추가 변경들을 적용하려고 시도하는지를 판정한다. 만일 그렇다면, 순서도(1400)는 블록 1412로 루프하고, 블록 1412는 추가 버퍼를 생성한다. 한편, 만일 블록 1418이 트랜잭션이 어떤 추가 변경도 적용하려고 시도하지 않는다고 판정하면, 블록 1420은 뒤의 섹션에서 설명되는 바와 같이, 변경들을 커밋하려고 시도할 것이다. 블록 1424는 또 다른 트랜잭션의 수신을 기다린다.

한편, 만일 블록 1410이 트랜잭션이 데이터베이스에 어떤 변경도 적용하려고 시도하지 않았다고 판정하면, 블록 1422는 단일 기입 버퍼 및 스위칭 포인터를 해제한다. 그 이유는 그것들이 필요하지 않기 때문이다. 블록 1424는 또 다른 트랜잭션의 수신을 기다린다.

트랜잭션 커밋

델타 페이저는 언제 트랜잭션들을 커밋할지를 판정하는 상이한 양태들을 지원한다. 델타 페이저는 다수의 트랜잭션들이 각 트랜잭션이 개시된 때에 존재하는 데이터베이스의 상태에 동시에 액세스하는 것을 허용한다. 그러나, 다수의 트랜잭션들이 동시에 실행할 때, 데이터베이스에 대해 첫 번째로 커밋되는 트랜잭션이 다른 동시에 실행중인 트랜잭션들이 의지하는 데이터베이스의 상태를 변경할 수 있다. 데이터베이스의 구식인(outdated) 또는 대체된(superseded) 상태에 기초한 트랜잭션들은 데이터베이스에 커밋되면 무효한 결과로 이를 수 있다. 따라서, 델타 페이저는 개입 트랜잭션들이 현 트랜잭션이 의지한 데이터베이스의 상태를 방해하지 않은 경우에만 현 트랜잭션을 커밋한다.

도 15는 델타 페이저가 트랜잭션 1(200)과 동시에 처리하여, 잠재적으로 충돌하는 트랜잭션들을 초래하는, 제2 트랜잭션인 트랜잭션 2(Tx2)(1500)를 예시한다. 잠재적으로 충돌하는 트랜잭션들과 마주하여, 델타 페이저는 데이터베이스에 어느 트랜잭션들을 커밋할지 및 어느 트랜잭션들을 중단할지를 판정한다. 트랜잭션 2(1500)는 복수의 명령들(1510-1570)을 호출한다. 그 명령들 중, 명령 1(1520), "x=Read(0)"과 같은, 어떤 명령은 데이터베이스로부러 데이터를 판독하려고 시도하는 반면, 명령 4(1550), "Write(3, "CAT")"와 같은, 다른 명령들은 데이터베이스에 변경을 적용하려고 시도한다.

도 16은 델타 페이저가 트랜잭션 1(200) 및 트랜잭션 2(1500) 둘 다를 수신하고 동시에 처리하는 상황을 예시한다. 어느 쪽의 트랜잭션이든 데이터베이스에 커밋되기 전에, 2개의 트랜잭션 중 어느 한쪽이 다른 것보다 전에 개시되었을 수 있다. 2개의 트랜잭션들 모두 현 상태 포인터(120)가 그때의 현 상태인 원 상태(110)로 계속해서 포인팅할 때 개시되었다.

델타 페이저는 전술한 바와 같이, 현 상태 포인터(120)에 의해 지시된 원 상태(110)로 포인팅하는 제1 기입 버퍼(310)를 생성함으로써 트랜잭션 1(200)을 개시하고, 그 트랜잭션에 대하여 가장 최근에 생성된 기입 버퍼로 포인팅하는 트랜잭션 포인터(320)를 생성한다. 델타 페이저는 트랜잭션 1(200)이 데이터베이스에 행하려고 시도하는 변경들을 저장하는 추가 기입 버퍼들(410 및 510)을 생성한다.

트랜잭션 2(1500)에 대하여, 델타 페이저는 원 상태(110)로 포인팅하는 제1 기입 버퍼(1610) 및 그 트랜잭션에 대하여 가장 최근에 생성된 기입 버퍼를 지시하는 트랜잭션 포인터(1620)를 생성한다. 유사하게, 델타 페이저는 트랜잭션 2(1500)에 대하여 추가 기입 버퍼들을 생성한다. 도 16에서, 명령 1(1520), "x=Read(0)" 및 명령 2(1530), "y=Read(1)"는 둘 다 원 상태(110)로부터 널 값들을 판독한다. 따라서, 조건 명령 2(1540), "If y=x then"이 참(true)이고, 명령 4(1550), "Write(3, "CAT")"가 실행된다. 델타 페이저는 제1 기입 버퍼(1610)로 포인팅하는 추가 기입 버퍼(1630)를 생성하고, 명령 4(1550)에 의해 지시된 변경을 추가 기입 버퍼(1630)에 저장하고, 트랜잭션 포인터(1620)를 추가 기입 버퍼(1630)로 포인팅한다. 트랜잭션 포인터(320)와 트랜잭션 포인터(1620) 모두 각 트랜잭션이 데이터베이스에 적용할 변경들을 포함하는 부분적 매핑들로 포인팅한다.

트랜잭션 1(200) 및 트랜잭션 2(1500)는 데이터베이스에 충돌하는 변경들을 행할 수 있고, 또는 명령 3(1540)과 같은 조건 명령이 다른 트랜잭션이 잠재적으로 변경하는 데이터에 의존할 수도 있다. 델타 페이저의 양태들은 이들 잠재적인 충돌들을 여러 가지 방법으로 고려한다.

개입 트랜잭션들이 현 상태를 변경할 경우 트랜잭션 중단

도 17 및 18은 델타 페이저가 데이터베이스의 상태를 변경하는 개입 트랜잭션을 커밋한 후에 트랜잭션을 중단함으로써, 잠재적으로 충돌하는 트랜잭션들을 처리하기 위해 이용하는 하나의 양태를 예시한다. 도 17에서, 델타 페이저는 도 6을 참조하여 전술한 바와 같이 데이터베이스에 트랜잭션 1(200)을 커밋하였다: 트랜잭션 포인터(320)는 제거되고, 현 상태 포인터(120)는 그 트랜잭션에 대하여 생성된 최후 기입 버퍼(510)로 포인팅하도록 스위칭된다. 데이터베이스에 트랜잭션 1(200)을 커밋한 후에, 델타 페이저는 트랜잭션 2(1500)가 실행을 완료하였다고 판정하고 데이터베이스에 커밋하려고 시도한다.

데이터베이스에 트랜잭션 2(1500)를 커밋할지를 판정함에 있어서, 델타 페이저는 트랜잭션 1(200)과 같은 개입 트랜잭션이 현 트랜잭션인 트랜잭션 2(1500)가 개시된 때에 존재하는 데이터베이스의 상태를 변경하였는지를 판정한다. 이 판정을 행하기 위해, 델타 페이저는 제1 기입 버퍼(1610)가 무슨 상태로 포인팅하는지를 판정함으로써 트랜잭션 2(1500)가 개시된 때의 데이터베이스의 상태를 비교한다. 그 후 델타 페이저는 그것을 현 상태 포인터(120)가 포인팅하는 데이터베이스의 현 상태와 비교한다. 환언하면, 델타 페이저는 현 상태 포인터(120)를 트랜잭션 포인터(1620)와 비교하고 기입 버퍼들(1610 및 1630)을 삽입하여 그것들 모두가 동일 개체로 포인팅하는지를 판정한다. 데이터베이스에 트랜잭션 1(200)을 커밋한 후에, 델타 페이저는 현 상태 포인터(120)는 기입 버퍼(510)로 포인팅하고, 한편 트랜잭션 2(1500)는, 그것의 제1 기입 버퍼(1610)를 통하여, 원 상태(110)로 포인팅한다고 판정한다.

트랜잭션 2(1500)는 현 상태 포인터(120)에 의해 지시된 현 상태와는 다른 상태로 포인팅하기 때문에, 델타 페이저는 트랜잭션 2(1500)를 중단한다. 도 18은 델타 페이저가 데이터베이스의 현 상태의 일부가 되지 않을 메모리를 자유롭게 하기 위해 기입 버퍼들(1610 및 1630) 및 트랜잭션 포인터(1620)를 삭제함으로써 트랜잭션 2(1500)를 중단한다.

현 상태에서의 어떤 변화 때문에 트랜잭션을 중단하는 것은 충돌하는 트랜잭션들의 커밋을 피하기 위한 위험회피형 접근법(risk-averse approach)이다. 도 16-18의 예에서와 같이, 트랜잭션 1(200)은 트랜잭션 2(1500)의 실행될 때 존재하는 데이터베이스의 상태에서의 어떤 값도 변경하지 않았다. 그러나, 개입 트랜잭션 1(200)이 트랜잭션 2(1500)가 의지한 데이터를 변경하였을 가능성이 있다. 트랜잭션 1(200)은 데이터베이스의 현 상태를 변경하였고, 따라서, 트랜잭션 2(1500)가 의지한 데이터를 변경하였을 수 있다.

트랜잭션 2(1500)가 중단되었다 하더라도, 그 트랜잭션은 도 19 및 20에 예시된 바와 같이 재개시될 수 있다. 도 19에서, 델타 페이저는 트랜잭션 1(200)이 커밋한 후에 트랜잭션 2(1500)를 개시한다. 따라서, 트랜잭션 2(1500)가 개시될 때, 델타 페이저는 트랜잭션 2(1500)가 재개시된 때 존재하는 상태로 포인팅하는 제1 기입 버퍼(1510)를 생성하다. 상태는 트랜잭션 1(200)에 의해 상태에 추가된 기입 버퍼(510)로 포인팅하는 현 상태 포인터(120)에 의해 지시된다. 그 후 델타 페이저는 원래 기입 버퍼(1910)로 포인팅한 트랜잭션 포인터(1920)를 생성한다. 델타 페이저는 추가 기입 버퍼(1930)를 추가하고, 그것에 델타 페이저는 트랜잭션 2(1500)가 데이터베이스에 적용하려고 시도하는 변경을 저장하고, 그 후 델타 페이저는 트랜잭션 2(1500)가 데이터베이스에 적용하려고 시도하는 변경들을 나타내는 부분적 매핑을 지시하기 위해 트랜잭션 포인터(1920)를 추가 기입 버퍼(1930)로 포인팅하도록 변경한다.

이때, 델타 페이저가 트랜잭션 2(1500)가 완전하고 데이터베이스에 트랜잭션을 커밋하려고 시도한다고 판정할 경우, 델타 페이저는 어떤 개입 트랜잭션도 데이터베이스의 현 상태를 트랜잭션 2(1500)가 의지한 상태로부터 변경하지 않은 것을 발견한다. 트랜잭션 포인터(1920)는, 기입 버퍼들(1930 및 1910)을 통하여, 기입 버퍼(510)로 포인팅한다. 현 상태 포인터는 여전히 기입 버퍼(510)로 포인팅하고, 따라서, 트랜잭션 포인터(1920)는 여전히 현 상태로 포인팅한다.

도 20은 델타 페이저가 데이터베이스에 트랜잭션 2(1500)를 커밋하는 것을 보여준다. 델타 페이저는 현 상태 포인터(120)를 트랜잭션 2(1500)에 의해 추가된 최후 버퍼인 기입 버퍼(1930)로 포인팅하도록 변경한다. 그 후 델타 페이저는 트랜잭션 포인터(1920)를 삭제한다. 현 상태 포인터가 이제 포인팅하는 현 상태는 트랜잭션 1(200)에 의해 적용된 기입 버퍼들(410 및 510) 및 트랜잭션 2(1500)에 의해 적용된 기입 버퍼(1930)에 저장된 변경들에 의해 변경된 원 상태(110)를 포함한다.

도 21은 델타 페이저가 트랜잭션들을 커밋할지 중단할지를 판정하기 위해 이용하는 이 제1 양태를 예시한다. 순서도(2100)는 블록 2102에서 시작한다. 블록 2102는 완전한 트랜잭션이 언제 데이터베이스에 커밋하려고 시도하는지를 판정하고, 순서도(2100)는 트랜잭션이 데이터베이스에 커밋하려고 시도할 때까지 블록 2102로 루프한다. 블록 2102가 커밋하려고 시도하는 완전한 트랜잭션을 검출하는 경우, 블록 2104는 현 상태가, 예를 들어, 현 트랜잭션에 대한 트랜잭션 포인터에 의해 지시된 바와 같이 트랜잭션이 개시된 때 존재하는 상태와 동일한지를 판정한다. 환언하면, 블록 2104는 트랜잭션에 대하여 생성된 제1 기입 버퍼가 현 상태 포인터가 포인팅하는 동일한 상태로 포인팅하는지를 판정한다. 만일 그렇다면, 블록 2106은 현 상태 포인터를, 트랜잭션 포인터도 포인팅하는 버퍼인, 트랜잭션에 대하여 생성된 최후 버퍼로 포인팅하여, 트랜잭션이 커밋되는 결과로서 데이터베이스의 업데이트를 완료한다. 블록 2108은 트랜잭션 포인터를 삭제하여, 관련 메모리를 자유롭게 한다. 순서도(2100)는 블록 2102로 루프하여 데이터베이스에 커밋하려고 시도하는 다음 완전한 트랜잭션을 검출한다.

한편, 만일 블록 2104가 현 상태가 트랜잭션이 개시된 때 존재하는 상태와 동일하지 않다고 판정하면, 블록 2104는 현 상태가 변경되었다고 판정한다. 블록 2110은 트랜잭션의 기입 버퍼들을 해제한다. 블록 2112는 트랜잭션 포인터를 삭제하여, 트랜잭션의 중단을 완료한다. 전술한 바와 같이, 중단된 트랜잭션은 재개시될 수 있고, 델타 페이저는 트랜잭션이 완전하고 커밋하려고 시도할 때 데이터베이스에 트랜잭션이 커밋되어야 할지를 판정할 것이다.

트랜잭션들이 불필요하게 중단되는 것을 방지하는 판독 버퍼들

델타 페이저가 트랜잭션이 현 상태와 일치하지 않는 상태로 포인팅할 때마다 현 트랜잭션을 중단하는 대신, 델타 페이저는 개입 트랜잭션이 현 트랜잭션이 판독한 데이터를 기입한 경우 현 트랜잭션을 중단할 수 있다. 현 상태가 변경된 때마다 현 상태를 중단하는 것은 어떤 충돌하는 변경도 데이터베이스에 적용되지 않는 것을 보장한다. 그러나, 동시에 실행되는 다수의 트랜잭션들이 있을 수 있고, 이 트랜잭션들 중 일부가 긴 또는 복잡한 계산들을 수반할 수 있는 경우, 트랜잭션들을 중단하는 것은 컴퓨팅 리소스들을 낭비한다. 따라서, 만일 개입 트랜잭션이 현 트랜잭션이 판독하거나 의지한 어떤 데이터도 액세스하거나 변경하지 않았다면, 델타 페이저가 현 트랜잭션을 중단하는 것은 불필요하다.

델타 페이저의 한 양태는 각 트랜잭션에 대하여 판독 버퍼를 생성한다. 판독 버퍼는 트랜잭션이 액세스하는 어떤 데이터도 추적한다. 완전한 트랜잭션이 데이터베이스에 커밋하려고 시도하지만, 개입 트랜잭션이 데이터베이스의 상태를 변경한 것을 발견하는 경우, 델타 페이저는 판독 버퍼를 데이터베이스의 현 상태와 비교하여 현 트랜잭션을 중단할 필요가 있는지를 판정할 수 있다. 다른 양태에서, 델타 페이저는 현 상태가 변경되었고 개입 트랜잭션이 현 트랜잭션이 판정한 데이터를 변경 또는 덮어쓰기한 경우 현 트랜잭션을 중단한다. 이 양태에서, 델타 페이저는 개입 트랜잭션이 현 트랜잭션에 의해 판독된 어드레스에 데이터를 기입했다면 트랜잭션을 취소할 수 있고, 또는 델타 페이저는 현 트랜잭션에 의해 판독된 실제 데이터와 개입 트랜잭션에 의해 기입된 데이터를 비교하여 데이터의 값이 실제로 변경되었는지를 판정할 수 있다.

도 22-24는 판독 버퍼들을 이용하고 개입 트랜잭션이 현 트랜잭션에 의해 판독된 데이터를 기입한 경우 트랜잭션을 중단하는 델타 페이저의 양태를 예시한다. 도 22는 데이터베이스의 현 상태에 대하여 실행되는, 2개의 트랜잭션들, 트랜잭션 1(2200) 및 트랜잭션 2(2250)를 보여준다. 현 상태 포인터(120)는 원 상태(110)로 포인팅하고, 그에 의해 데이터베이스의 현 상태 또는 현 상태를 지시한다. 트랜잭션 1(2200)에 대하여, 델타 페이저는 판독 버퍼(2210), 기입 버퍼(2220), 및 트랜잭션 포인터(2230)를 생성한다. 전술한 바와 같이, 델타 페이저는 각 트랜잭션에 대하여 하나 이상의 기입 버퍼들을 생성할 수 있다. 델타 페이저는 또한, 판독 버퍼들이 크기에서 또는 다른 이유로 제한되면, 둘 이상의 판독 버퍼를 생성할 수도 있다. 델타 페이저는 판독 버퍼(2210)를 현 상태로 포인팅하고, 기입 버퍼(2220)를 판독 버퍼(2210)로 포인팅하고, 트랜잭션 포인터(2230)를 기입 버퍼(2220)로 포인팅한다. 그에 대응하여, 트랜잭션 2(2250)에 대하여, 델타 페이저는 판독 버퍼(2260), 기입 버퍼(2270), 및 트랜잭션 포인터(2280)을 생성한다. 델타 페이저는 판독 버퍼(2260)를 현 상태로 포인팅하고, 기입 버퍼(2270)를 판독 버퍼(2260)로 포인팅하고, 트랜잭션 포인터(2280)를 기입 버퍼(2270)로 포인팅한다.

트랜잭션 1(2200)에 대한 판독 버퍼(2210)는 트랜잭션 1(2200)이 어드레스 3에서 데이터를 판독하였다는 것을 지시한다. 트랜잭션 2(2250)에 대한 판독 버퍼(2260)는 트랜잭션 2(2230)도 어드레스 3에서 데이터를 판독하였다는 것을 지시한다. 그러나, 트랜잭션들 각각이 동일 데이터를 판독했다 하더라도, 트랜잭션들 중 어느 쪽도 그 어드레스에서 데이터를 변경하려고 시도하지 않는다. 따라서, 델타 페이저는 할 수 없이 트랜잭션들 중 어느 쪽도 중단하지는 않는다.

판독 버퍼는, 빈 기입 버퍼처럼, 데이터베이스의 상태를 변경하지 않는다. 따라서, 델타 페이저의 실시예들은 마치 데이터가 저장되어 있는 개체인 것처럼 데이터베이스의 현 상태에 있지 않은 판독 버퍼를 이용할 수 있다. 대신, 델타 페이저는 델타 페이저가 트랜잭션이 적용하려고 시도하는 변경들을 저장하기 위해 생성할 수 있는 부분적 매핑 외부에 저장될 수 있다. 판독 버퍼는 별도의 위치에 저장될 수 있고, 트랜잭션 포인터는 판독 버퍼의 위치를 지시하는 별도의 포인터를 포함할 수 있다.

만일 델타 페이저가 개입 트랜잭션이 현 트랜잭션에 의해 판독된 어드레스에서 데이터를 변경하는 경우에만 현 트랜잭션을 중단할 것이라면, 판독 버퍼는 도 25-27을 참조하여 아래에서 설명되는 바와 같이, 판독된 값 및 어드레스를 저장해야 할 것이다. 한편, 만일 델타 페이저가, 개입 트랜잭션이 동일 값을 기입한다 하더라도, 개입 트랜잭션이 현 트랜잭션에 의해 판독된 데이터를 덮어쓰기하는 경우, 트랜잭션을 중단할 것이라면, 판독 버퍼는 도 22-24에 예시된 바와 같이 트랜잭션이 판독하는 어드레스 또는 어드레스들을 포함하기만 하면 된다.

도 23은 델타 페이저가 데이터베이스에 트랜잭션 1(2200)을 커밋한 후에 데이터베이스의 상태를 예시한다. 델타 페이저는 현 상태 포인터(120)를 트랜잭션 1(2200)에 대하여 생성된 최후 기입 버퍼(2220)로 포인팅하고 트랜잭션 포인터(2230)를 삭제한다. 일단 트랜잭션 2(2250)가 완전하면, 델타 페이저는 트랜잭션 2(2250)를 커밋해야 할지를 판정한다. 다시, 데이터베이스의 현 상태는 델타 페이저가 트랜잭션 2(2250)를 커밋하기 전에 변경되었기 때문에, 도 15-21을 참조하여 전술한 트랜잭션들을 커밋할지를 판정하는 양태에서, 델타 페이저는 트랜잭션 2(2250)를 중단할 것이다. 현 양태는, 대조적으로, 보다 실질적인 평가를 행한다.

이 양태에서는, 데이터베이스의 현 상태가 변경되었다 하더라도, 델타 페이저는 개입 트랜잭션이 현 트랜잭션에 의해 액세스된 어드레스에 데이터를 기입하지 않은 한은 현 트랜잭션을 중단하지 않는다. 델타 페이저는 트랜잭션 2(2250)의 판독 버퍼(2260)를 비교하여 개입 트랜잭션인 트랜잭션 1(2200)이 트랜잭션 2(2250)가 데이터를 판독한 어드레스에 기입했는치를 판정하고, 그에 의해 처리 또는 트랜잭션 2(2250)가 의지한 상태를 변경한다. 트랜잭션 2(2250)는, 판독 버퍼(2260)에 따라서, 어드레스 3으로부터 데이터를 판독만 하였다. 그러나, 현 상태 포인터(120)에 의해 지시된 현 상태를 체크하여, 트렌잭션 1(2200)은, 기입 버퍼(2220)에 따라서, 어드레스 4에 데이터를 기입만 하였다. 따라서 델타 페이저는 데이터베이스에 트랜잭션 2(2250)를 커밋한다.

도 24는 델타 페이저가 데이터베이스의 현 상태에 트랜잭션 2(2250)를 커밋하는 것을 예시한다. 델타 페이저는 트랜잭션 2(2250)의 판독 버퍼(2260)를 현 상태 포인터에 의해 지시된 개체인, 트랜잭션 1(22DO)의 기입 버퍼(2220)로 포인팅한다. 그 후 델타 페이저는 현 상태 포인터(120)를 트랜잭션 2(2250)의 기입 버퍼(2270)로 포인팅하도록 변경하여, 데이터베이스에 트랜잭션 2(2250)를 커밋한다.

도 25-27은 델타 페이저가 개입 트랜잭션이 개입 트랜잭션이 데이터를 기입한 어드레스에 기입할 뿐만 아니라, 개입 트랜잭션이 현 트랜잭션이 판독한 데이터 값을 실제로 변경하는 경우에만 현 트랜잭션을 중단하는 보다 작은 위험회피형 양태(a less risk-averse mode)를 예시한다. 도 25는 데이터베이스의 현 상태에 대하여 실햄되는, 2개의 트랜잭션, 트랜잭션 2(2500) 및 트랜잭션 2(2550)를 보여준다. 현 상태는 데이터베이스의 원 상태(110)로 포인팅하는, 현 상태 포인터(120)에 의해 지시된다. 트랜잭션 1(2500)에 대하여, 델타 페이저는 판독 버퍼(2510), 기입 버퍼(2520), 및 트랜잭션 포인터(2530)를 생성한다. 델타 페이저는 판독 버퍼(2510)를 그때의 현 상태로 포인팅하고, 기입 버퍼(2520)를 판독 버퍼(2510)로 포인팅하고, 트랜잭션 포인터(2530)를 기입 버퍼(2520)로 포인팅한다. 그에 대응하여, 트랜잭션 2(2550)에 대하여, 델타 페이저는 판독 버퍼(2560), 기입 버퍼(2570), 및 트랜잭션 포인터(2580)을 생성한다. 델타 페이저는 판독 버퍼(2560)를 그때의 현 상태로 포인팅하고, 기입 버퍼(2570)를 판독 버퍼(2560)로 포인팅하고, 트랜잭션 포인터(2580)를 기입 버퍼 (2570)로 포인팅한다.

트랜잭션 1(2500)에 대한 판독 버퍼(2510)는, 도 22-24의 예와는 대조적으로, 트랜잭션 1(2500)은 어드레스 3의 값을 판독하였고, 어드레스 3으로부터 판독된 값은 널이었다는 것을 나타낸다. 트랜잭션 2(2550)에 대한 판독 버퍼(2560)는 트랜잭션 2(2550)도 어드레스 3의 값을 판독하였고 또한 어드레스 3으로부터 판독된 값은 널이라는 것을 발견하였음을 나타낸다. 트랜잭션 2(2550)에 대한 기입 버퍼(2570)는, 저장된 값을 문자열 "CAT"로 변경하는, 어드레스 2의 값에 대한 변경을 저장한다.

도 26은 델타 페이저가 데이터베이스에 트랜잭션 2(2550)를 커밋한 후 데이터베이스의 현 상태를 나타낸다. 따라서, 델타 페이저는 현 상태 포인터(120)를 트랜잭션 2(2550)이 데이터베이스에 적용하는 임의의 변경들을 저장하는 기입 버퍼(2570)로 포인팅하도록 변경하고, 트랜잭션 포인터(2580)를 버린다. 이 양태에서, 일단 트랜잭션 1(2500)이 완전하면, 델타 페이저는 트랜잭션 1(2500)이 트랜잭션 2(2550)가 변경한 데이터를 판독하였는지를 판정한다.

델타 페이저는 트랜잭션 1(2500)의 판독 버퍼(2510)를 현 상태 포인터(120)에 의해 지시된 데이터베이스의 현 상태와 비교한다. 판독 버퍼(2510)에 따르면, 트랜잭션 1은 어드레스 3을 판독하였고 그 값이 널임을 발견하였다. 델타 페이저는 또한 현 상태 포인터(120)에 의해 지시된 데이터베이스의 현 상태를 따르고 트랜잭션 2(2550)가 어드레스 3에 저장된 값을 "CAT"로 변경하였음을 발견한다. 따라서, 트랜잭션 1(2500)이 데이터베이스에 적용하려고 시도하는 어떤 변경이든 이제는 구식인 데이터에 기초하였을 수 있다.

따라서, 델타 페이저는 도 27에 예시된 바와 같이 트랜잭션 1(2500)을 중단한다. 델타 페이저는 판독 버퍼(2510), 기입 버퍼(2520), 및 트랜잭션 포인터(2530)를 해제 또는 삭제하고, 델타 페이저는 현 상태 포인터(120)를 트랜잭션 2(2550)가 데이터베이스에 적용한 변경들을 저장하는 기입 버퍼(2570)로 포인팅된 상태로 놔둔다. 원한다면, 트랜잭션 1(2200)은 그 후 전술한 바와 같이 재개시될 수 있다.

트랜잭션 2(2550)가 트랜잭션 1(2500)에 의해 판독된 어드레스에 새로운 값을 기입하였다 하더라도, 트랜잭션 2(2550)가 기입한 데이터는 트랜잭션 1(2500)의 결과를 변경하지 않았을 수 있다는 것에 유의한다. 그러나, 트랜잭션 2(2550)에 의해 기입된 데이터의 결과로 트랜잭션 1(2500)의 결과가 변경될지를 판정하기 위해, 트랜잭션 1(2500)이 재실행되어야 할 것이다. 델타 페이저의 이 양태는 단지 현 상태가 변경되었기 때문에 트랜잭션 1(2500)을 중단하지 않지만, 시간을 들어 트랜잭션 1(2500)을 재실행하는 것을 제쳐놓고 현 트랜잭션을 중단해야 하는지에 대한 어떤 실질적인 분석을 제공한다.

도 28은 델타 페이저가 트랜잭션을 커밋해야 할지를 판정하는 보다 실질적인 양태들을 용이하게 하기 위해 판독 버퍼 및 단일 기입 버퍼를 생성함으로써 트랜잭션들을 처리하기 위해 델타 페이저가 이용하는 양태를 예시한다. 델타 페이저는 판독 버퍼를 이용하는 것과 관련하여 단일 기입 버퍼를 이용하는 것에 제한되지 않고, 단일 기입 버퍼의 선택은 하나의 가능한 대안일 뿐이다.

순서도(2800)는 블록 2802가 트랜잭션을 수신할 때 시작한다. 블록 2804는 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경들의 부분적 매핑을 지시할 스위칭 포인터를 생성한다. 블록 2806은 판독 버퍼를 생성하고 그것을 트랜잭션이 개시된 때에 존재하는 상태로 포인팅한다. 블록 2808은 단일 기입 버퍼를 생성하고 그 단일 기입 버퍼를 판독 버퍼로 포인팅한다. 블록 2810은 트랜잭션이 적용하려고 시도하는 변경들의 부분적 상태를 지시하기 위해 스위칭 포인터를 단일 기입 버퍼로 포인팅한다.

블록 2812는 트랜잭션에 의해 판독된 임의의 데이터를 판독 버퍼에 저장한다. 전술한 바와 같이, 델타 페이저가 개입 트랜잭션이 현 트랜잭션과 동일한 데이터를 판독한 경우에 트랜잭션을 중단할 수 있는 양태에서, 판독 버퍼는 판독된 데이터의 어드레스만 저장하면 된다. 한편, 델타 페이저가 개입 트랜잭션이 현 트랜잭션에 의해 판독된 데이터를 기록하였는지에 기초하여 트랜잭션을 커밋할지를 판정한다면, 판독 버퍼는 어드레스 및 그 어드레스로부터 판독된 데이터 둘 다를 저장해야 한다.

블록 2814는 트랜잭션이 데이터베이스에 변경을 적용하려고 시도하는지를 판정한다. 만일 그렇다면, 블록 2816은 스위칭 포인터를 단일 기입 버퍼로부터 다른 데로 포인팅한다. 블록 2818은 단일 기입 버퍼에 변경을 저장한다. 블록 2820은 스위칭 포인터를 단일 기입 버퍼로 포인팅한다.

블록 2822는 트랜잭션이 완전한지 또는 계속해서 실행되는지를 판정한다. 만일 트랜잭션이 완전하지 않으면, 순서도(2800)는 블록 2812로 루프하여 트랜잭션에 의해 판독된 임의의 데이터를 판독 버퍼에 저장한다. 한편, 블록 2822가 트랜잭션이 완전하다고 판정하면, 블록 2824는 트랜잭션에 의해 행해진 변경들을 커밋하려고 시도할 것이다. 블록 2826은 또 다른 트랜잭션의 수신을 기다린다.

도 29는 델타 페이저가 트랜잭션을 커밋할지 중단할지를 판정하기 위해 판독 버퍼들을 이용하는 일 양태를 예시한다. 순서도(2900)는 블록 2902에서 시작한다. 블록 2902는 완전한 트랜잭션이 언제 데이터베이스에 커밋하려고 시도하는지를 판정하고, 순서도(2900)는 트랜잭션이 데이터베이스에 커밋하려고 시도할 때까지 블록 2902로 루프한다. 블록 2902가 커밋하려고 시도하는 완전한 트랜잭션을 검출하는 경우, 블록 2904는 트랜잭션이 개시된 이후 현 상태가 변경되었는지를 판정한다.

만일 현 상태가 변경되지 않았다면, 블록 2912는 현 상태 포인터를 단일 기입 버퍼, 즉 트랜잭션 포인터도 포인팅하는 버퍼인, 트랜잭션에 대하여 생성된 복수의 기입 버퍼들 중 최후의 기입 버퍼로 포인팅한다. 블록 2914는 트랜잭션 포인터를 삭제하여, 데이터베이스의 업데이트를 완료한다. 만일 데이터베이스의 현 상태가 변경되지 않았다면, 델타 페이저는 판독 버퍼를 검사하거나 또는 데이터베이스에 적용된 것을 검색하지 않고 트랜잭션을 커밋할 수 있다. 만일 현 상태가 변경되지 않았다면, 어떤 개입 트랜잭션들도 현 트랜잭션이 의지하는 데이터를 변경하지 않았을 것이다. 순서도(2900)는 블록 2902로 루프하여 데이터베이스에 커밋하려고 시도하는 다음 완전한 트랜잭션을 검출한다.

한편, 만일 블록 2904가 현 상태가 트랜잭션이 개시된 이후 변경되었다고 판정하면, 블록 2906은 판독 버퍼에 리스트된 데이터가 현 상태에서 변경되었는지를 판정한다. 다시, 델타 페이저의 이 양태는 델타 페이저가 개입 트랜잭션을 커밋한 결과로서 현 상태가 변경된 경우에만 판독 버퍼를 검사한다. 만일 판독 버퍼에 리스트된 데이터가 현 상태에서 변경되지 않았다면, 델타 페이저는 트랜잭션을 커밋할 것이고 순서도(2900)는 블록 2912로 진행한다.

한편, 만일 블록 2906이 현 상태에서 판독 버퍼 내의 어드레스에 데이터가 기입된 것을 발견하거나, 또는 만일 그 어드레스의 데이터의 값이 판독 버퍼에 저장되어 있는 것과 다르다면, 델타 페이저는 트랜잭션을 중단한다. 블록 2908은 트랜잭션에 대한 판독 및 기입 버퍼들을 해제한다. 그 후 블록 2910은 현 트랜잭션에 대한 트랜잭션 포인터를 해제 또는 삭제하여, 트랜잭션의 중단을 완료한다. 그 후 순서도(2900)는 블록 2902로 루프하여 커밋하려고 시도하는 다음 트랜잭션을 기다린다.

트랜잭션 합체 및 상태 보전

델타 페이저의 기입 버퍼들은 다수의 이점들을 제공한다. 일례를 들면, 트랜잭션이 커밋될 수 없고 중단되어야 하는 경우, 델타 페이저는 그 트랜잭션에 대하여 생성한 기입 버퍼들을 무시 또는 삭제하고, 델타 페이저는 다른 경우라면 데이터베이스에 적용되었을지 모르는 잘못된 또는 충돌하는 변경들을 재기입 또는 실행 취소(undo)할 필요가 없다. 그러나, 델타 페이저가 현 상태에 다수의 기입 버퍼들을 추가한 후, 현 상태 내의 모든 데이터에의 액세스가 무효하게 될 수 있다. 도 20의 비교적 단순한 예에서도, 트랜잭션은 그 트랜잭션이 판독하려고 시도하는 데이터의 값을 판정하기 위해 기입 버퍼들(1930, 1910, 510, 410, 310), 및 원 상태(110)를 통하여 판독해야 할 것이다. 델타 페이저의 일 양태는 데이터베이스의 현 상태에의 유효한 액세스를 보장하기 위해 기입 버퍼들을 합체한다.

도 30은 델타 페이저가 도 20의 기입 버퍼들을 합체할 수 있는 방법의 일 양태를 예시한다. 도 30에서, 델타 페이저는 기입 버퍼들에 저장된 변경들을 데이터베이스의 원 상태(110)에 적용함으로써 기입 버퍼들을 합체한다. 제1 단계(3000)에서, 델타 페이저는 기입 버퍼들이 합체될 포인트를 지시하는 합체 포인터(coalesce pointer)(3010)를 인지한다. 합체 포인터(3010)의 이점은 아래에서 더 설명한다. 그 후 델타 페이저는 원 상태(110)로 포인팅하는 제1 기입 버퍼에 저장된 변경을 적용한다. 도 30이 예시하는 바와 같이, 제1 기입 버퍼는 빈 기입 버퍼(310)였다. 델타 페이저는 현 상태로부터 빈 기입 버퍼를 생략함으로써 기입 버퍼(310)와 같은 빈 버퍼를 합체한다.

빈 기입 버퍼(310)는 트랜잭션이 데이터베이스에 적용하려고 시도하는 변경들을 나타내는 부분적 매핑을 변경하지 않는다는 것에 유의한다. 따라서, 델타 페이저가 트랜잭션이 적응하려고 시도하는 변경을 저장하는 기입 버퍼를 생성하자마자, 빈 기입 버퍼는 즉시 버려질 수 있고, 또는 델타 페이저는 빈 기입 버퍼(310)를 생성조차 할 수 없다. 예를 들면, 일단 어드레스 4의 값을 변경하기 위해 기입 버퍼(510)가 추가되면, 델타 페이저의 일 실시예는 기입 버퍼(510)를 트랜잭션이 개시된 때 존재하는 상태로 포인팅하고, 빈 기입 버퍼(310)를 버릴 수 있다.

제2 단계(3020)에서, 델타 페이저는 다음 기입 버퍼(410)에 저장된 변경을 원 상태(110)에 적용하여, 원 상태를 업데이트된 상태(3030)로 대체한다. 어드레스 2의 값을 1로 설정하는, 기입 버퍼(410)에 저장된 변경은 어드레스 2(3040)에 적용되어 업데이트된 배킹 저장소(backing store)(3030)를 생성한다.

최종 결과(3050)는 데이터베이스의 새로운 상태(3060)를 보여준다. 새로운 상태(3060)에서, 기입 버퍼(510)에 저장된 변경은 어드레스 4(3070)에 저장된 값을 문자열 "DOG"로 변경하도록 적용되었고, 기입 버퍼(1930)에 저장된 변경은 어드레스 3(3080)에 저장된 값을 문자열 "CAT"로 변경하도록 적용되었다. 델타 페이저는 이제 현 상태 포인터(120)를 새로운 상태(3060)로 포인팅하도록 스위칭한다. 그 후 델타 페이저는 합체 포인터(3010)를 생략한다.

델타 페이저의 버퍼 합체에 관하여 4가지 유의할 점이 있다. 첫째로, 합체 프로세스 중에도, 각 포인터는 계속해서 불변으로 데이터베이스의 동일 상태로 포인팅한다. 예를 들면, 제2 단계(3020)에서, 델타 페이저가 기입 버퍼(410) 내의 변경을 원 상태(110)에 적용하여 업데이트된 상태(3030)를 생성한 경우, 다른 포인터들에 의해 지시된 상태들은 동일하게 유지되었다. 현 상태 포인터(120), 기입 버퍼들(510, 1910, 및 1930), 및 합체 포인터(3010)는 모두 여전히 모두 동일 값들을 제공하는 데이터베이스의 상태로 포인팅하였다.

둘째로, 만일 데이터베이스의 현 상태를 변경하기 위해 하나 이상의 새로운 트랜잭션들이 개시되어 커밋되었다면, 새로운 트랜잭션들은 계속해서 데이터베이스의 불변 상태로 포인팅할 것이다. 새로운 트랜잭션을 개시할 때, 델타 페이저는 현 상태 포인터(120)에 의해 지시된 현 상태로 포인팅하는 기입 버퍼들을 생성한다. 만일 델타 페이저가 트랜잭션을 커밋하면, 델타 페이저는 현 상태 포인터(120)를 각각의 후속 트랜잭션들에 대하여 생성된 최후 기입 버퍼로 포인팅하도록 스위칭한다. 따라서, 델타 페이저는 기입 버퍼들을 합체하는 중에도 새로운 트랜잭션들에 대한 상태들의 불변성을 보전한다.

셋째로, 합체 포인터(3010)는 합체 프로세스가 정지할 포인트를 지시한다. 델타 페이저가 현 상태에 추가 기입 버퍼들을 커밋하는 경우, 델타 페이저는 델타 페이저가 추가 합체에 착수할 때까지는 추가 버퍼들을 합체하지 않을 것이다. 합체는 무기한 계속될 수 있지만, 컴퓨팅 리소스들을 극히 소수의 새로운 기입 버퍼들일 수 있는 것을 끊임없이 합체하는 데 바치는 것은 컴퓨팅 리소스들의 효율적인 사용은 아닐 것이다.

넷째로, 도 31에 도시된 바와 같이, 델타 페이저는 데이터베이스의 원 상태(110)를 덮어쓰기하지 않고 버퍼들을 합체할 수 있다. 예를 들면, 원 상태(110)는 액세스하기에 비효율적일 수 있는 디스크 저장소에 저장될 수 있고, 또는 후속 트랜잭션들에 의해 적용되는 변경들 없이 원 상태(110)를 유지하려는 소망이 있을 수 있다. 따라서, 델타 페이저는 기입 버퍼들을 하나 이상의 중간 개체들에 합체할 수 있다.

도 31에서, 기입 버퍼들을 중간 개체에 합체하는 제1 단계(3100)에서, 델타 페이저는 합체될 기입 버퍼들 중 제1 기입 버퍼인 기입 버퍼(310)와 원 상태(110) 사이에 중간, 합체 개체(3110)를 생성한다. 합체 개체(3110)를 삽입하는 것은 데이터베이스 내의 현 상태들 중 어떤 것의 불변성도 변경하지 않는다: 현 상태 포인터(120) 및 기입 버퍼들(310, 410, 510, 1910, 및 1930)은 여전히 데이터베이스의 동일 상태로 포인팅한다. 합체 개체(3110)는 물론, 원 상태(110)는, 캐시 메모리, 메모리, 디스크, 또는 다른 형태의 저장소를 포함한, 임의의 원하는 저장소에 유지될 수 있다.

최종 결과(3120)는 델타 페이저가 기입 버퍼들(410, 510, 및 1930)에 저장된 모든 변경들을 합체 개체(3110)에 합체한 것을 보여준다. 따라서, 어드레스 2의 값을 1로 변경하는, 기입 버퍼(410)에 저장된 변경은, 원 상태(110)에 적용되는 대신, 합체 개체(3110)의 어드레스 2(3130)에 저장된다. 유사하게, 델타 페이저는 기입 버퍼들(510 및 1930)로부터의 변경들을 합체 개체(3110)의 어드레스 3(3140) 및 어드레스 4(3150)에 각각 저장한다. 델타 페이저는 현 상태 포인터(120)를 합체 개체(3110)로 포인팅하도록 변경하고, 합체 개체(3110)는 원 상태(110)로 포인팅한다. 따라서, 데이터베이스의 상태는 결코 변경되지 않았고, 현 상태 포인터(120)는 델타 페이저가 기입 버퍼들을 합체 개체(3110)에 합체하기 전에 존재하는 데이터베이스의 동일 상태로 계속해서 포인팅한다.

유리하게는, 데이터를 판독하려고 시도하는 새로운 트랜잭션들은 이제 2개의 데이터 저장소, 즉 합체 개체(3110) 및 원 상태(110)만 체크하면 된다. 만일 나중에 원한다면, 델타 페이저는 합체 개체(3110)의 콘텐츠를 원 상태에 합체하여 업데이트된 배킹 저장소를 생성할 수 있다. 대안적으로, 델타 페이저는 합체 개체를 유지하고 동일한 합체 개체(3110)로의 기입 버퍼들의 후속 합체를 수행할 수도 있다. 또 대안적으로, 델타 페이저는, 스냅숏에 관하여 아래에서 더 설명되는 바와 같이, 추가 합체 개체들을 생성할 수 있다.

전술한 바와 같이, 델타 페이저는 포인터들의 불변성을 유지한다. 데이터베이스 내의 합체 개체들에서, 각 개체가 추가된 때에 존재하는 중간 상태들을 나타내는 버퍼들 간의 포인터들은 현 상태가 보전되는 한은 제거된다. 그러나, 만일 다음의 버퍼로부터의 포인터 이외의 포인터가 버퍼로 포인팅하면, 델타 페이저에 의해 인지된 불변성은 그 포인터에 의해 지시된 상태가 버퍼들의 합체에서 살아남아야 하는 것을 보장한다. 델타 페이저의 포인터들의 불변성을 이용하여, 델타 페이저는 스냅숏 포인터들을 고려할 것이고, 이 스냅숏 포인터들은 선택된 상태로 포인팅하고 델타 페이저가 스냅숏 포인터에 선행하거나 그 다음에 오는 버퍼들을 합체하는 경우에도 그 상태를 보전한다.

도 32는 델타 페이저가 스냅숏 포인터(3210)를 이용하여 보전할 데이터베이스의 현 상태를 예시한다. 현 상태 포인터(120)는, 기입 버퍼들(3220, 3230, 및 3240)에 의해 원 상태(110)가 변경되어 있는, 현 상태로 포인팅한다. 제1 기입 버퍼(3220)는 문자열 "PEAR"를 어드레스 0에 기입한다. 제2 기입 버퍼(3230)는 값 1을 어드레스 2에 기입한다. 제3 기입 버퍼(3240)는 문자열 "DOG"를 어드레스 4에 기입한다.

델타 페이저가 현 상태를 보전하도록 지시를 받는 경우, 델타 페이저는 현 상태로 포인팅하는 스냅숏 포인터(3210)를 생성한다. 델타 페이저는, 예를 들어, 정기 백업들(regular backups)을 자동으로 보전하는 프로그램 또는 사용자가 현 상태와 같은 상태의 스냅숏을 요구하는 경우 상태를 보전하기 위해 스냅숏 포인터(3210)를 삽입한다. 스냅숏 포인터(3210)는 선택된 상태로 포인팅하기 때문에, 델타 페이저는 델타 페이저에 의해 고려되는 포인터들의 불변성의 결과로 그 포인터 및 대응하는 상태를 유지할 것이다.

도 33은 추가 트랜잭션들이 현 상태를 변경한 후의 데이터베이스의 나중 상태를 예시한다. 제4 기입 버퍼(3310)는 문자열 "PEACH"를 어드레스 0에 기입한다. 제5 기입 버퍼(3320)는 문자열 "CAT"를 어드레스 4에 기입한다. 델타 페이저는 현 상태 포인터(120)를 제5 기입 버퍼(3320)로 포인팅하도록 스위칭한다. 도 33에서, 제5 기입 버퍼(3320)는 어드레스 4에 저장된 문자열 "DOG" 기입 버퍼(3240)를 문자열 "CAT"로 덮어쓰기한다. 그러나, 스냅숏 포인터(3310)는, 여전히 도 32의 상태를 나타내는 기입 버퍼(3240)로 포인팅한다.

도 34는 델타 페이저에 의해 허용된 합체를 예시한다. 델타 페이저가 원 상태(110)를 덮어쓰기하지 않을 경우를 가정하여, 델타 페이저는 원 상태의 배킹 저장소와 스냅숏 포인터(3210) 사이의 기입 버퍼들(3220, 3230, 및 3240)에 의해 적용된 변경들을 제1 합체 개체(3410) 내에 수집함으로써 데이터베이스의 현 상태에서 개체들을 합체한다. 그 후 델타 페이저는 기입 버퍼들(3310 및 3320)에 의해 적용된 변경들을 제2 합체 개체(3420) 내에 수집한다. 현 상태 포인터(120)는 제2 합체 개체(3420)로 포인팅한다. 제2 합체 개체(3420)는 제1 합체 개체(3410)로 포인팅하고, 제1 합체 개체(3410)는 원 상태(110)로 포인팅한다.

델타 페이저는 스냅숏 개체(3210)의 포인터의 불변성을 보전하기 위해 별개의 합체 개체들(3410 및 3420)을 이용한다. 스냅숏 개체(3210)가 존재하는 한은, 델타 페이저는 도 32의 선택된 상태를 유지할 것이다. 따라서, 예를 들어, 도 33 및 34의 현 상태에서, 델타 페이저는 기입 버퍼(3240)에 의해 어드레스 4에 저장된 문자열 "DOG"를 기입 버퍼(3320)에 의해 어드레스 4에 저장된 문자열 "CAT"로 대체한다. 그러나, 스냅숏 포인터(3210)에 의해 보전된 선택된 상태에서, 문자열 "DOG"는 제1 합체 개체(3410) 내의 어드레스 4에 저장된 채로 유지된다.

스냅숏 포인터(3210)에 관하여 5가지 유의할 점이 있다. 첫째로, 델타 페이저는 스냅숏 포인터를 추가함으로써 임의의 선택된 시간에 데이터베이스의 상태를 보전할 수 있다. 둘째로, 델타 페이저는 다수의 상태를 보전하기 위해 다수의 스냅숏 포인터를 포함할 수 있다. 셋째로, 합체에 관련하여 상술한 바와 같이, 델타 페이저는 포인터들의 불변성 때문에 하나 이상의 전 상태들(earlier states)을 보전하면서 계속해서 트랜잭션들을 수신하고 데이터베이스에 변경들을 커밋할 수 있다. 넷째로, 스냅숏 포인터(3210)에 의해 보전된 상태가 더 이상 필요하지 않을 경우, 스냅숏 포인터(3210)는 제거되고, 후속 합체가 보전된 상태를 해제할 것이다.

다섯째로, 스냅숏 포인터들은 델타 페이저가 다수의 상이한 상태들을 단일 데이터 저장소에 유지하는 것을 가능하게 한다. 현 상태들을 유지하기 위해 종래의 데이터베이스들의 백업 이미지들이 저장되는 경우, 각 이미지는 개별적으로 저장된다. 그 이유는 후속 이미지들이 이전 이미지들을 덮어쓰기하기 때문이다. 다수의 상태들은 대용량의 저장소를 소비할 수 있고, 백업 이미지들은 보다 고속의 장치들에서 저장 공간을 보전하기 위해 종종 보다 저속의 저장 장치들로 퇴거(relegate)된다. 그러나, 델타 페이저는 전 상태들 상에 후속 상태들을 구축하기 때문에, 스냅숏 포인터들은 전 상태들을 단일 데이터 저장소 내에 보전한다.

도 35는 델타 페이저가 버퍼들, 또는 이제 더 합체될 이전에 생성된 합체 개체들과 같은 다른 개체들을 합체하는 일 양태들 예시한다. 순서도(3500)는 블록 3502에서 시작한다. 블록 3502는 데이터베이스의 현 상태에서의 개체들의 합체를 개시한다. 프로그램이 이따금 합체를 개시할 수 있고, 또는 사용자가 합체를 개시할 수도 있다. 블록 3504는, 도 34의 예에서와 같이 원 상태를 포함할 수 있는 합체 시작 포인트, 최후 합체 개체, 또는 델타 페이저가 그로부터 데이터베이스에 추가된 버퍼들을 합체할 다른 포인트를 식별한다. 블록 3506은 다음 비합체 개체(next noncoalesced object)로 진행한다. 도 33의 예에서는, 원 상태(110)에서 시작하여, 블록 3504는 다음 비합체 개체로서, 기입 버퍼(3220)를 합체하기 위한 시작 포인트를 식별한다.

블록 3508은 다음 합체 개체로부터 이외의 버퍼로의 포인터가 있는지를 판정한다. 델타 페이저는 데이터베이스의 상태가 변경되지 않은 겅우 일련의 버퍼들 또는 다른 개체들을 합체할 때 포인터들을 제거할 수 있지만, 델타 페이저는 스냅숏 포인터(3210)로부터의 포인터와 같은 다른 포인터들은 제거하지 않을 것이다. 만일 블록 3508이 다음 버퍼로부터 이외의 다른 포인터가 없다고 판정하면, 블록 3510은 합체 개체에서 버퍼를 다음 생성된 버퍼와 결합한다. 블록 3512는 잠재적으로 합체할 추가 개체가 있는지를 판정한다. 추가 개체는 다음 생성된 버퍼를 포함할 수 있고, 또는, 만일 데이터베이스 내의 개체들이 이전에 합체되었다면, 더 합체될 합체 개체가 있을 수 있다. 만일 잠재적으로 합체할 추가 개체가 있다면, 순서도(3500)는 블록 3506으로 루프하여 다음 비합체 개체로 진행한다. 그러나, 블록 3512는 합체할 다른 개체가 없다고 판정할 수 있다. 예를 들어, 만일 델타 페이저가 데이터베이스를 완전히 합체하였다면, 델타 페이저는 합체되지 않는 현 상태 포인터(120)에 도달할 것이다. 블록 3512가 합체할 추가 개체가 없다고 판정하는 경우, 블록 3514는 합체를 완료한다. 합체 완료는, 예를 들면, 동작의 완료를 확인하는 메시지를 송신 또는 로그(log)할 수 있다.

한편, 블록 3508은 상태 내에 다음 개체 이외로부터의 포인터가 있다고 판정할 수 있다. 예를 들면, 도 32-34에 예시된 바와 같이, 스냅숏 포인터(3210)는 개체가 나타내는 상태를 보전하기 위해 개체로 포인팅할 수 있다. 블록 3508이 다른 포인터가 있다고 판정하는 경우, 순서도(3500)는 블록 3512로 진행하여 잠재적으로 합체할 추가 개체가 있는지를 판정한다.

상태들을 영속성 있게 만들기( Making States Durable )

델타 페이저는 데이터베이스이 선택된 부분들이 영속성 있게(durable) 되는 것을 가능케 한다. 델타 페이저는 데이터베이스의 선택된 부분들을 보전하기 위해 그것들을 비휘발성 저장소에 커밋할 것이다.

도 36은 부분적으로는 영속성 매체(durable medium)인 디스크(3610) 상에 저장되고, 부분적으로는 휘발성 매체인 메모리(3620)에 저장된 개체들을 포함하는 데이터베이스의 현 상태를 예시한다. 현 상태 포인터(120)는 현 상태로 포인팅하고, 이 현 상태는 디스크(3610) 상에 저장된 원 상태(110)를 포함하고 그 현 상태에 델타 페이저가 기입 버퍼들(3630 및 3640) 내의 변경들을 커밋하였다.

일 양태에서, 델타 페이저는 프로그램 또는 사용자가 영속성 포인터(durable pointer)(3650)를 삽입함으로써 데이터베이스의 선택된 부분을 영속성 있게 만드는 것을 가능케 한다. 영속성 포인터(3650)는 영속성 있게 만들어질 개체들을 포함하는 데이터베이스의 상태로 포인팅한다. 도 36에서, 영속성 포인터(3650)는 제1 기입 버퍼(3630)를 포함하는 상태로 포인팅한다.

도 37이 예시하는 바와 같이, 델타 페이저는 영속성 포인터(3250)에 의해 지시된 상태에 포함된 임의의 개체를 디스크 저장소(3710)와 같은 영속성 저장 가능한 저장소로 이동시킨다. 본 예에서, 제1 기입 버퍼(3630)는 디스크 저장소(3710)로 이동된다. 델타 페이저는 데이터베이스의 상태가 임의의 수의 저장 매체에 걸쳐서 존재하는 것을 가능케 한다. 따라서, 델타 페이저가 제1 기입 버퍼(3630)를 기입하는 디스크 저장소(3710)는 원 상태(110)가 존재하는 디스크 저장소(3610)와 동일한 저장 장치일 수도 있고, 또는 그것은 별개의 저장 장치일 수도 있다. 영속성 포인터(3650)가 포인팅하는 상태에 포함되지 않은, 제2 기입 버퍼(3640)는 메모리(3620)에 남겨진다.

일단 델타 페이저가 영속성 포인터(3650)에 의해 지시된 데이터베이스의 현 상태의 일부분을 영속성 저장소에 저장하면, 델타 페이저는 영속성 포인터를 해제할 수 있다. 델타 페이저는 데이터베이스의 선택된 부분이 영속성 있게 된 것을 확인하는 메시지를 발생시킬 수 있다.

도 38은 델타 페이저가 버퍼들을 영속성 있게 만드는 일 양태를 예시한다. 순서도(3500)는 블록 3802에서 시작한다. 블록 3802은 영속성 요구(durability request)를 수신한다. 블록 3804는 영속성 있게 만들어질 데이터베이스의 부분을 판정하기 위해 영속성 포인터를 찾아낸다(locate). 블록 3806은 영속성 포인터와 영속성 있게 만들어질 데이터베이스 내의 최후 영속성 저장 부분 사이의 모든 개체들을 식별한다. 블록 3808은 영속성 포인터와 최후 영속성 저장소 사이의 모든 개체들을 영속성 저장 개체에 복사한다. 블록 3810은 영속성 있게 만들어질 현 상태의 부분으로 포인팅하는 임의의 포인터들을 영속성 저장 개체로 변경한다. 도 37의 예에서, 델타 페이저는 기입 버퍼(3640)의 포인터를 영속성 개체로 변경한다. 대안적으로, 예를 들어, 현 상태 포인터(120) 또는 스냅숏 포인터(3210)와 같이, 영속성 포인터(3650)가 포인팅하는 상태로의 다른 포인터들이 있다면, 이들 포인터들도 블록 3808에 의해 생성된 영속성 개체로 포인팅될 것이다.

일단 영속성 포인터(3650)가 포인팅하는 상태 내의 개체들이 영속성 개체에 복사되고 그 상태로의 포인터들이 변경되었다면, 블록 3812는 영속성 포인터가 포인팅하는 메모리 내의 개체들을 해제하여 그 메모리를 다른 용도를 위해 해제한다. 블록 3814는 영속성 포인터를 삭제한다. 블록 3816은, 예를 들어, 영속성 요구를 행하는 사용자에게 메시지를 송신하거나 또는 시스템 로그에 메시지를 추가함으로써, 영속성 요구의 완료를 확인한다.

데이터 캐싱

델타 페이저는 또한 성능 향상을 위해 데이터를 캐싱하는 것을 가능케 한다. 델타 페이저는, 예컨대 도 7-9를 참조하여 설명된 일련의 누적 버퍼들을 이용하여, 데이터의 이중 저장을 가능케 한다. 상태 내에 데이터의 이중 저장은 상태를 변경하지 않는다. 따라서, 델타 페이저는 디스크 저장소 또는 다른 대용량 저장소 등의 저속 저장소에 저장된 데이터를, 상태를 변경하지 않고, 메모리 등의 고속 저장소에 캐싱할 수 있다.

도 39는 캐시 개체(3910)를 포함하는 데이터베이스의 현 상태를 예시한다. 캐시 개체(3910)는, 디스크 저장소(3950)에 저장된 영속성 개체(3930)와 같은, 캐싱될 개체로 포인팅한다. 델타 페이저는 이 경우 판독 버퍼(3962)인, 영속성 개체(3930)에 저장되지 않은 제1 개체를 캐시 개체(3910)로 포인팅한다.

현 상태에서, 만일 트랜잭션이 어드레스 0의 값을 찾는다면, 그 트랜잭션은, 문자열 "CAT"를 현 상태에 기입하는, 기입 버퍼(3968) 내의 어드레스 0에 대한 현 값을 찾을 것이다. 트랜잭션은 기입 버퍼(3968) 이외에 더 볼 필요가 없고, 트랜잭션은 메모리 검색 속도로 어드레스 0의 값을 수신할 것이다. 한편, 만일 트랜잭션이 어드레스 2에 저장된 값을 찾는다면, 델타 페이저는 그것을 발견할 때까지 현 상태의 전체에 걸쳐서 그 값을 찾을 것이다. 캐시 개체(3910)가 없다면, 델타 페이저는 디스크 저장소(3950) 내의 영속성 개체(3930)로 갈 것이다. 디스크 저장소(3950)로부터 데이터를 액세스하는 것은 메모리(3960)를 액세스하는 것에 비하여 느리다. 메모리(3930)에 캐시 개체(3910)를 생성하는 것은 액세스 효율을 향상시킬 수 있다.

도 39의 예에서, 영속성 개체(3930)는 값 1을 저장하는 어드레스 2(3932), 문자열 "CAT"를 저장하는 어드레스 3(3934), 및 문자열 "DOG"를 저장하는 어드레스 4(3936) 등의, 어드레스들의 범위에 값들을 저장한다. 영속성 개체(3930)는 또한 어떤 데이터도 저장되어 있지 않은 널 값들(3940)의 범위를, 문자열 "ROCK"을 저장하는 어드레스 99(3938)까지 저장한다.

델타 페이저는 메모리(3960)에 캐시 개체(3910)를 생성한다. 델타 페이저는 캐시 개체(3910)를, 이 경우, 영속성 개체(3930)인, 캐싱되는 개체로 포인팅한다. 그 후 델타 페이저는 제1 비영속성 개체인, 판독 버퍼(3962)를 캐시 개체(3910)로 포인팅한다.

일단 델타 페이저가 캐시 개체를 생성하고 현 상태에 캐시 개체를 삽입하도록 포인터들을 변경하면, 델타 페이저는 캐시를 채운다(populate). 일 양태에서, 델타 페이저가 영속성 개체(3930)로부터 데이터를 검색하는 경우, 델타 페이저는 동일 데이터를 캐시 개체(3910)에 저장한다. 또한, 시간을 들여 영속성 개체에 액세스한 후, 델타 페이저는 영속성 개체(3930)로부터 데이터의 블록을 검색하고 그것을 캐시 개체(3910)에 저장할 수 있다. 예를 들어, 캐시 개체(3910)가 채워지기 전에, 델타 페이저가 판독 버퍼(3962)를 생성한 트랜잭션은 영속성 개체(3930) 내의 어드레스 4(3936)에 저장되어 있는, 데이터를 어드레스 4로부터 찾는다. 영속성 개체(3930)에 액세스하는 동안, 델타 페이저는 또한 어드레스 2(3932), 어드레스 3(3934), 및 다른 어드레스들 내지 어드레스 99(3938)로부터의 데이터를 포함하는 블록에 대한 데이터를 검색하고, 그 어드레스들의 데이터를 캐시 개체(3910)에 저장한다.

델타 페이저가 영속성 개체(3980)로부터 검색된 데이터를 캐시 개체(3910)에 저장한 후, 캐시 개체(3910)에 복사된 데이터에 대한 후속 요구들은 훨씬 빠른 메모리 속도로 수행될 것이다. 따라서, 만일 판독 버퍼(3962)가 생성된 트랜잭션이 그 후 어드레스 99로부터 데이터를 요구하면, 델타 페이저는 캐시 개체(3910) 내의 어드레스 99(3918)로부터 데이터를 검색할 수 있다. 유사하게, 만일 판독 버퍼(3964)가 생성된 트랜잭션이 어드레스 3으로부터 데이터를 요구하면, 델타 페이저는 델타 페이저가 디스크 저장소(3950)로부터 데이터를 검색하는 것을 기다리지 않고 캐시 개체 내의 어드레스 3(3914)로부터 데이터를 검색할 수 있다.

델타 페이저의 캐시 개체(3910)에 관하여 3가지 유의할 특징이 있다. 첫째로, 캐시 개체(3910)의 삽입은 델타 페이저가 데이터 상태들을 생성하고 이용하는 방법을 변경하지 않는다. 예를 들어, 캐시 개체(3910) 내의 어드레스 4(3916)가 문자열 "DOG"를 저장하더라도, 기입 버퍼(3966)는 문자열 "BIRD"를 기입 버퍼(3966) 내의 어드레스 4에 기입함으로써 데이터베이스의 상태를 변경할 수 있다. 후속 트랜잭션들에서, 현 상태 포인터(3966)가 포인팅하는 현 상태는, 캐시 개체(3910)가 어드레스 4(3916)에 무엇을 저장하든 관계없이, 문자열 "BIRD"가 어드레스 4에 저장되어 있는 것을 발견할 것이다.

둘째로, 만일 캐시 개체(3910)를 이용하는 상태들이 영속성 있게 되면, 델타 페이저는 캐시 개체(3910)를 재개시하고 다시 채울(repopulate) 필요가 없다. 대신, 데이터가 영속성 저장소에 복사되므로, 디스크에 복사되는 상태 내의 데이터가 캐시 개체(3910)에 저장된 데이터와 다른 경우, 델타 페이저는 캐시 개체(3910) 내의 데이터를 업데이트할 수 있다. 대안적으로, 델타 페이저는 영속성 저장소에 복사되는 상태와 비교할 때 더 이상 현재가 아닌 캐시 개체(3910) 내의 엔트리(entry)들을 무효화할 수 있다. 양쪽 모두의 기법들은 구식 상태의 캐시를 변경하여 그것을 업데이트된 상태의 유효 캐시로 만든다. 그렇게 함으로써, 델타 페이저는 캐시 개체를 무기한 재사용한다. 만일 캐시가 업데이트들에 걸쳐서 보전될 수 없다면, 업데이트들이 영속성 있게 만들어질 때마다 캐시를 재구성하는 데 있어서 유효성이 상실될 것이다.

셋째로, 델타 페이저는 캐시 개체(3910)를 이용하여 범위 쿼리(range queries)를 용이하게 할 수 있다. 캐시 개체는 배킹 저장소에 범위 쿼리를 발행함으로써 널들의 런들(runs of nulls)을 발견할 수 있고, 그러한 런을 캐시 개체 또는 델타 페이저에 의해 유지되는 다른 개체의 일부분에 콤팩트하게 표현할 수 있다. 예를 들면, 널들의 런의 표현은 캐시 개체 내의 필드에 포함될 수 있다. 그 표현을 메모리에 저장된 개체에 유지하는 것은 널들의 연속의 표현에의 액세스 속도를 향상시켜 범위 쿼리를 용이하게 할 것이다. 예를 들어, 만일 트랜잭션이 "BIRD", "CAT", 또는 "DOG" 뒤에 다음 애완 동물(pet) 문자열을 발견하기를 원했다면, "DOG" 뒤에 영속성 개체(3930)에 긴 문자열의 널 데이터(3940)가 있는 경우, 캐시 개체(3910)는 예컨대 어드레스 5(3920)에 대한, 제1 널 어드레스 필드에, 널 값을 저장하는 런 내의 어드레스들 중 최후, 또는 널이 아닌 값을 저장하는 어드레스들 중 최초를 나타내는 엔트리를 포함할 수 있다.

도 40은 델타 페이저가 캐시 개체들을 유지하는 일 양태를 예시한다. 순서도(4000)는 블록 4002에서 시작한다. 블록 4002는 메모리 또는 다른 고속 액세스 저장소에 캐시 개체를 생성한다. 블록 4004는 캐시 개체를 캐싱되는 개체로 포인팅한다. 블록 4006은 캐싱되는 개체로 포인팅하는 개체를 식별하고, 그 개체를 캐시 개체로 포인팅한다. 블록 4008은 캐싱되는 개체로부터 트랜잭션에 의해 판독된 데이터 및 어드레스들을 캐시 개체에 저장한다. 전술한 바와 같이, 델타 페이저가 캐싱되는 개체로부터 데이터를 검색하는 경우, 바람직하게는 델타 페이저는 잠재적으로 후속 디스크 액세스 동작들에 대한 필요를 피하기 위해 판독된 어드레스에 인접한 어드레스들의 블록으로부터 데이터를 검색할 것이다.

블록 4010은 캐시 개체로 포인팅하는 상태가 영속성 있게 되어야 할지를 판정한다. 만일 그렇지 않다면, 순서도(4000)는 블록 4008로 루프하여 트랜잭션들에 의해 판독된 데이터 및 어드레스들을 캐시 개체에 저장하는 것을 계속한다. 그러나, 블록 4010이 캐시로 포인팅하는 상태가 영속성 있게 되어야 할 것이라고 판정하면, 블록 4012는 영속성 있게 만들어지는 개체 내의 변경들로 캐시 엔트리들을 업데이트한다. 대안적으로, 델타 페이저는 구식인 캐시 엔트리들을 업데이트하는 대신 그것들을 무효화할 수 있다. 일단 블록 4012가 캐시 엔트리들을 업데이트하면, 블록 4014는 영속성 있게 만들어지지 않은 제1 개체를 캐시 개체로 포인팅한다.

델타 페이저에 의해 이용되는 개체들

요약을 위하여, 도 41은 전술한 예시적인 동작들을 용이하게 하기 위해 델타 페이저가 이용하는 개체들을 예시한다. 이 요약에서 나타내어지는 일반 개체들을 참조하기 위해 새로운 참조 번호들이 이용된다. 도 41은 영속성 디스크 저장소(4120) 및 메모리(4130)에 저장된 그러한 개체들의 범위를 예시적인 상황(4100)을 예시한다.

델타 페이저는 디스크 저장소(4120) 내의 하나 이상의 영속성 개체들(4122 및 4124)을 이용할 수 있다. 이들 개체들은 전술한 바와 같이 영속성 있게 된 원 상태 및 임의의 다른 상태들을 저장할 수 있다. 예를 들면, 그것이 포인팅하는 상태 뒤에 제거되어, 영속성 개체(4124)에서 명시(manifest)될 것이 때문에 점선 윤곽으로 표시된 영속성 포인터(4126)가 영속성 있게 되었다. 영속성 개체들은 하나 이상의 장치 상에 저장될 수 있다.

델타 페이저는 메모리(4130)에 저장된 복수의 개체들을 포함할 수 있다. 델타 페이저는 캐싱될 수 있는 영속성 개체들(4122 및 4124)과 후속 개체들 사이에 삽입된 캐시 개체(4140)를 포함할 수 있다. 스냅숏 포인터(4152)에 의해 보전된 상태를 포함하는 스냅숏 개체(4150)가 캐시 개체(4140)로 포인팅한다. 이 스냅숏 개체(4150)는 합체 개체들 또는 일련의 비합체 개체들을 포함하는 선택된 상태를 포함한다. 전술한 바와 같이, 스냅숏 포인터(4152)는 보전된 상태에 포함된 또는 보전된 상태에 나중에 추가된 개체들이 합체되더라도 상태를 보전할 수 있다.

최후 합체 동작이 합체 개체(4160)를 생성한 이후, 판독 버퍼(4170) 및 기입 버퍼(4180)와 같은 복수의 버퍼들이 현 상태에 추가된다. 현 상태 포인터(4190)는 현 상태를 지시한다.

예시적인 실시예들을 구현하기 위한 운영 환경

도 42는 델타 페이저를 구현하기 위한 예시적인 운영 환경(4200)을 예시한다. 운영 환경(4200)은 적합한 운영 환경의 일례에 불과하며, 전술한 델타 페이저의 예시적인 실시예들, 또는 다른 실시예들의 용도 또는 기능성의 범위에 관해 어떤 제한을 암시하고자 하는 것이 아니다. 운영 환경(4200)은 예시적인 운영 환경(4200)에 도시된 컴포넌트들 중 임의의 하나 또는 그 컴포넌트들의 임의의 조합과 관련하여 어떤 의존성 또는 요구사항을 갖는 것으로 해석되어서도 안 된다.

델타 페이저를 구현하는 프로세스들은 일반적으로 운영 환경(4200)에서 실행되는 프로그램 모듈과 같은 컴퓨터 실행가능 명령어와 관련하여 기술될 수 있다. 일반적으로, 프로그램 모듈은 특정 태스크를 수행하거나 특정 추상 데이터 유형을 구현하는 루틴, 프로그램, 개체, 컴포넌트, 데이터 구조 등을 포함한다. 더욱이, 숙련된 당업자들은 델타 페이저를 구현하는 프로세스들이, 핸드-헬드 장치, 멀티프로세서 시스템, 마이크로프로세서 기반 또는 프로그램 가능한 소비자 전자 기기, 미니컴퓨터, 메인프레임 컴퓨터 등을 포함하는, 각종의 컴퓨터 시스템 구성을 이용하여 실시될 수 있다는 것을 알 것이다. 델타 페이저를 구현하는 프로세스들은 통신 네트워크를 통해 연결되어 있는 원격 처리 장치들에 의해 태스크가 수행되는 분산 컴퓨팅 환경들에서 실시될 수도 있다. 분산 컴퓨팅 환경에서, 프로그램 모듈은 메모리 저장 장치를 비롯한 로컬 및 원격 컴퓨터 저장 매체 둘 다에 위치할 수 있다.

도 42를 참조하면, 델타 페이저의 프로세스들을 구현하기 위한 예시적인 운영 환경(4200)은 처리 장치(4220), 시스템 메모리(4230), 및 시스템 메모리(4230)를 비롯한 각종 시스템 컴포넌트들을 처리 장치(4220)에 연결시키는 시스템 버스(4221)를 포함하는 컴퓨터(4210)를 포함한다.

컴퓨터(4210)는 통상적으로 각종 컴퓨터 판독가능 매체를 포함한다. 예로서, 컴퓨터 판독가능 매체는 컴퓨터 저장 매체 및 통신 매체를 포함하지만 이에 제한되는 것은 아니다. 컴퓨터 저장 매체의 예로는, RAM(Random Access Memory), ROM(Read Only Memory), EEPROM(Electronically Erasable Programmable Read Only Memory), 플래시 메모리 또는 기타 메모리 기술; CD-ROM, DVD(digital versatile disk), 또는 기타 광학 또는 홀로그래픽 디스크 저장 장치; 자기 카세트, 자기 테이프, 자기 디스크 저장 장치, 또는 기타 자기 저장 장치; 또는 컴퓨터(4210)에 의해 액세스될 수 있고 원하는 정보를 저장하는 데 이용될 수 있는 임의의 기타 매체를 포함하지만 이에 제한되는 것은 아니다. 시스템 메모리(4230)는 ROM(4231) 및 RAM(4232)과 같은 휘발성 및/또는 비휘발성 메모리 형태의 컴퓨터 저장 매체를 포함한다. (예컨대 시동 중에) 컴퓨터(4210) 내의 구성요소들 사이의 정보 전송을 돕는 기본 루틴을 포함하는 기본 입/출력 시스템(BIOS)(4233)은 통상적으로 ROM(4231)에 저장되어 있다. RAM(4232)은 통상적으로 처리 장치(4220)가 즉시 액세스 할 수 있고 및/또는 현재 동작시키고 있는 데이터 및/또는 프로그램 모듈을 포함한다. 예로서, 도 42는 운영 체제(4234), 애플리케이션 프로그램(4235), 기타 프로그램 모듈(4236) 및 프로그램 데이터(4237)를 도시하고 있지만 이에 제한되는 것은 아니다.

컴퓨터(4210)는 또한 기타 이동식/비이동식, 휘발성/비휘발성 컴퓨터 저장매체를 포함할 수 있다. 단지 예로서, 도 42는 비이동식, 비휘발성 자기 매체에 기록을 하거나 그로부터 판독을 하는 하드 디스크 드라이브(4241), 이동식, 비휘발성 자기 디스크(4252)에 기록을 하거나 그로부터 판독을 하는 자기 디스크 드라이브(4251), 및 CD-ROM 또는 기타 광학 매체 등의 이동식, 비휘발성 광 디스크(4256)에 기록을 하거나 그로부터 판독을 하는 광 디스크 드라이브(4255)를 예시한다. 예시적인 운영 환경에서 사용될 수 있는 기타 이동식/비이동식, 휘발성/비휘발성 컴퓨터 기억 매체로는 자기 테이프 카세트, 플래시 메모리 유닛, DVD, 디지털 비디오 테이프, 고상(solid state) RAM, 고상 ROM 등이 있지만 이에 제한되는 것은 아니다. 하드 디스크 드라이브(4241)는 통상적으로 인터페이스(4240)와 같은 비이동식 메모리 인터페이스를 통해 시스템 버스(4221)에 접속된다. 자기 디스크 드라이브(4251) 및 광 디스크 드라이브(4255)는 통상적으로 인터페이스(4250)와 같은 이동식 메모리 인터페이스에 의해 시스템 버스(4221)에 접속된다.

위에서 설명되고 도 42에 도시된 드라이브들 및 이들과 관련된 컴퓨터 저장 매체는, 컴퓨터(4210)에 대한 컴퓨터 판독가능 명령어, 데이터 구조, 프로그램 모듈 및 기타 데이터를 저장한다. 예를 들어, 하드 디스크 드라이브(4241)는 운영 체제(4244), 애플리케이션 프로그램(4245), 기타 프로그램 모듈(4246), 및 프로그램 데이터(4247)를 저장하는 것으로 도시되어 있다. 여기서 주의할 점은 이들 컴포넌트가 운영 체제(4234), 애플리케이션 프로그램(4235), 기타 프로그램 모듈(4236), 및 프로그램 데이터(4237)와 동일하거나 그와 다를 수 있다는 것이다. 통상적으로, RAM에 저장되어 있는 운영 체제, 애플리케이션 프로그램 등은 하드 디스크 드라이브(4241)로부터 판독된 대응하는 운영 체제, 프로그램, 또는 데이터의 부분들이고, 그 부분들은 원하는 기능들에 따라서 크기 및 범위가 달라진다. 여기에서 운영 체제(4244), 애플리케이션 프로그램(4245), 기타 프로그램 모듈(4246) 및 프로그램 데이터(4247)에는 다른 번호가 부여되어, 최소한, 그들이 서로 다른 사본(copy)이라는 것을 예시한다. 사용자는 키보드(4262); 통상적으로 마우스, 트랙볼, 또는 터치 패드로 불리는 포인팅 장치(4262); 무선 입력 수신 컴포넌트(4263); 또는 리모트 컨트롤 등의 무선 소스와 같은 입력 장치를 통해 명령 및 정보를 컴퓨터(4210)에 입력할 수 있다. 다른 입력 장치(도시 생략)로는 마이크, 조이스틱, 게임 패드, 위성 안테나, 스캐너, 따위를 포함할 수 있다. 이들 및 기타 입력 장치는 종종 시스템 버스(4221)에 결합된 사용자 입력 인터페이스(4260)를 통해 처리 장치(4220)에 접속되지만, 예를 들어, 병렬 포트, 게임 포트, IEEE(4294) 포트, USB(universal serial bus)(4298), 또는 적외선(IR) 버스(4299) 등의 다른 인터페이스 및 버스 구조에 의해 접속될 수도 있다. 전술한 바와 같이, 입출력 기능들은 통신 네트워크를 통하여 분산 방식으로 용이하게 될 수 있다.

디스플레이 장치(4291)도 비디오 인터페이스(4290) 등의 인터페이스를 통해 시스템 버스(4221)에 접속될 수 있다. 디스플레이 장치(4291)는 컴퓨터(4210)의 출력을 디스플레이하는 어떠한 장치라도 될 수 있고, 모니터, LCD 화면, TFT 화면, 평판 디스플레이, 종래의 텔레비전, 또는 스크린 프로젝터에 한정되지 않는다. 디스플레이 장치(4291) 외에, 컴퓨터들은 또한 스피커(4297) 및 프린터(4296) 등의 기타 주변 출력 장치를 포함할 수 있고, 이들은 출력 주변장치 인터페이스(4995)를 통해 접속될 수 있다.

컴퓨터(4210)는 원격 컴퓨터(4280)와 같은 하나 이상의 원격 컴퓨터로의 논리적 접속을 사용하여 네트워크화된 환경에서 동작할 것이다. 원격 컴퓨터(4280)는 퍼스널 컴퓨터일 수 있고, 비록 도 42에는 메모리 저장 장치(4281)만 도시되어 있지만, 통상적으로 컴퓨터(4210)와 관련하여 상술된 구성요소들의 다수 또는 그 전부를 포함한다. 도 42에 도시된 논리적 접속으로는 LAN(local area network)(4271) 및 WAN(wide-area network)(4273)이 포함되지만, 또한 MAN(metropolitan-area network), 인트라넷, 또는 인터넷으로의 접속과 같은 다른 네트워크들을 포함할 수도 있다.

LAN 네트워킹 환경에서 사용될 때, 컴퓨터(4210)는 네트워크 인터페이스 또는 어댑터(4270)를 통해 LAN(4271)에 접속된다. WAN 네트워킹 환경에서 사용될 때, 컴퓨터(4210)는 통상적으로 인터넷과 같은 WAN(4273)을 통해 통신을 설정하기 위한 모뎀(4272) 또는 기타 수단을 포함할 수 있다. 내장형 또는 외장형일 수 있는 모뎀(4272)은 네트워크 인터페이스(4270) 또는 기타 적절한 메커니즘을 통해 시스템 버스(4221)에 접속될 수 있다. 모뎀(4272)은 케이블 모뎀, DSL 모뎀, 또는 기타 광대역 장치일 수 있다. 네트워크화된 환경에서, 컴퓨터(4210) 또는 그의 일부와 관련하여 기술된 프로그램 모듈은 원격 메모리 저장 장치 내에 저장될 수도 있다. 예로서, 도 42는 원격 애플리케이션 프로그램(4285)이 메모리 장치(4281)에 있는 것으로 도시하고 있지만 이에 제한되는 것은 아니다. 도시된 네트워크 접속은 예시적인 것이며 컴퓨터들 사이에 통신 링크를 설정하는 기타 수단이 사용될 수도 있다.

컴퓨터(4210)의 다수의 다른 내부 컴포넌트들은 도시되어 있지 않지만, 통상의 기술을 가진 당업자라면 그러한 컴포넌트들 및 상호 접속들이 잘 알려져 있음을 알 것이다. 예를 들면, 텔레비전 튜너 카드 및 네트워크 인터페이스 카드 등의 각종 확장 카드를 컴퓨터(4210) 내에 포함하는 것은 관례이다. 따라서, 델타 페이저를 구현하는 프로세스들의 예시적인 실시예들을 설명함에 있어서 컴퓨터(4210)의 내부 구성에 관한 추가 상세는 개시될 필요가 없다.

컴퓨터(4210)가 온 되거나 리셋되는 경우, ROM(4231)에 저장되어 있는 BIOS(4233)는 처리 장치(4220)에게, 운영 체제, 또는 그의 필요한 부분을 하드 디스크 드라이브(4241)로부터 RAM(4232)으로 로딩하도록 지시한다. 일단 운영 체제(4244)로 지정된 운영 체제의 복사된 부분이 RAM(4232)에 로딩되면, 처리 장치(4220)는 운영 체제 코드를 실행하고 운영 체제(4234)의 사용자 인터페이스와 연관된 시각적 요소들이 디스플레이 장치(4291) 상에 디스플레이되게 한다. 통상적으로, 애플리케이션 프로그램(4245)이 사용자에 의해 열리는 경우, 프로그램 코드 및 관련 데이터가 하드 디스크 드라이브(4241)로부터 판독되고 필요한 부분들이 RAM(4232) 내로 복사되고, 그 복사된 부분은 여기에서 참조 번호 4235로 표시되어 있다.

결론

예시적인 실시예들은 구조적 특징 및/또는 방법적 액트(act)들에 특정한 언어로 기술되었지만, 첨부된 청구항들은 반드시 전술한 특정 특징들 또는 액트들에 한정되지는 않는다는 것을 이해해야 할 것이다. 오히려, 그 특정 특징들 및 액트들은 예시적인 실시예들로서 개시되어 있다.

Claims (20)

1. 데이터베이스를 관리하기 위한 컴퓨터 구현 방법으로서,

   상기 데이터베이스를 부분적 매핑들(100, 310)의 시리즈(a series of partial mappings)로서 유지하는 단계 - 상기 부분적 매핑들 각각은 어드레스의 값에의 할당을 적어도 하나(at least one assignment of an address to a value) 포함함 - ;

   선택된 부분적 매핑의 상태(state)를 상기 시리즈에 이전에 추가된 선행 부분적 매핑(110)에 추가(append)된 상기 부분적 매핑(310)의 컴파일(compilation)로서 인지하는 단계;

   상기 선택된 부분적 매핑(310)으로의 포인터(120)를 확립하는 단계; 및

   상기 포인터(120)가 확립된 상기 선택된 부분적 매핑의 상태에 어떤 변경도 없도록 상기 선택된 부분적 매핑(110, 310)에의 변경들을 제한하는 단계

   를 포함하는 데이터베이스를 관리하기 위한 컴퓨터 구현 방법.
2. 제1항에 있어서, 상기 선택된 매핑 내의 상기 어드레스의 상기 값에의 할당을 판정하는 단계를 더 포함하고,

   이 단계는,

   상기 포인터(120)에 의해 지시된 상기 상태로부터 시작하여 상기 포인터(120)에 의해 지시된 상기 상태로부터 상기 시리즈의 반대 단(opposite end) 쪽 으로 진행하는 단계; 및

   상기 어드레스의 상기 값에의 제1 할당이 발견되는 것과, 상기 시리즈의 단부에 도달하는 것 중 하나가 충족될 때까지 상기 선택된 부분적 매핑에 액세스하는 단계를 포함하는 방법.
3. 제1항에 있어서, 상기 선택된 부분적 매핑은 상기 부분적 매핑들의 시리즈에 가장 최근에 추가된 상기 부분적 매핑(310)을 포함하고, 상기 선택된 부분적 매핑으로의 상기 포인터는 현 상태 포인터(a current state pointer)(120)를 포함하는 방법.
4. 제3항에 있어서,

   트랜잭션이 상기 데이터베이스에서 변경하려고 시도하는 적어도 하나의 할당에 대한 새로운 부분적 매핑(310)을 생성하는 단계; 및

   상기 새로운 부분적 매핑(310)을 상기 트랜잭션이 개시된 때 상기 현 상태 포인터(120)에 의해 지시된 상기 상태로 포인팅하는 단계

   를 더 포함하는 방법.
5. 제4항에 있어서,

   상기 현 상태 포인터(120)가 상기 트랜잭션이 개시된 때 상기 현 상태 포인터(120)에 의해 지시된 상기 상태로 계속해서 포인팅하는 경우와,

   어떤 개입 트랜잭션(intervening transaction)도 상기 트랜잭션이 개시된 때 상기 현 상태 포인터(120)에 의해 지시된 상기 상태와 상기 현 상태 포인터(120)에 의해 지시된 새로운 상태 사이에 상기 트랜잭션에 의해 액세스된 이전 할당을 변경하지 않은 경우

   중 하나의 경우에, 상기 현 상태 포인터(120)를 상기 새로운 부분적 매핑으로 포인팅함으로써 일단 상기 트랜잭션의 실행이 완전(complete)하면 상기 트랜잭션을 커밋(commit)하는 단계를 더 포함하는 방법.
6. 제5항에 있어서, 상기 트랜잭션이 커밋되지 않는 경우, 상기 새로운 부분적 매핑을 버림으로써 상기 트랜잭션을 중단하는 단계를 더 포함하는 방법.
7. 제1항에 있어서, 상기 선택된 부분적 매핑의 스냅숏(snapshot)(3210)을 보전하기 위해 상기 선택된 부분적 매핑으로 상기 포인터가 확립되는 방법.
8. 제1항에 있어서,

   어떤 포인터도 확립되지 않은 상기 시리즈 내의 제1 부분적 매핑(3110)을 식별하는 단계;

   상기 제1 부분적 매핑(3110)이 상기 시리즈에 추가된 후에 상기 시리즈에 추가된 제2 부분적 매핑을 식별하는 단계;

   상기 제1 부분적 매핑에 이전에 포함되지 않은 상기 제2 부분적 매핑에 포함 된 임의의 할당을 상기 제1 부분적 매핑(3110)에 추가하는 것과, 상기 제1 부분적 매핑(3110)과 상기 제2 부분적 매핑 양쪽 모두에 포함된 임의의 할당을 상기 제2 부분적 매핑에 포함된 할당으로 덮어쓰기(overwrite)하는 것

   중 하나에 의해, 상기 제2 부분적 매핑에 포함된 각 할당을 상기 제1 부분적 매핑(3110)에 삽입하는 단계; 및

   상기 시리즈로부터 상기 제2 부분적 매핑을 제거하는 단계

   를 더 포함하는 방법.
9. 제1항에 있어서, 저속 저장소(low-speed store)로부터의 데이터를 고속 저장소(high-speed store)에 캐싱하는 단계를 더 포함하고,

   이 단계는,

   제1 부분적 매핑(3910)을 상기 고속 저장소(3960)에 저장하는 단계;

   제2 부분적 매핑(3930)을 상기 저속 저장소(3950)에 저장하는 단계; 및

   상기 제1 부분적 매핑(3910)의 제1 상태가 상기 제2 부분적 매핑(3930)에의 참조에 의해 정의되도록 상기 시리즈 내의 상기 부분적 매핑들을 순서화(order)하는 단계

   를 포함하는 방법.
10. 제9항에 있어서, 상기 고속 저장소(3960)는 메모리를 포함하고 상기 저속 저장소(3950)는 디스크 저장소를 포함하는 방법.
11. 제9항에 있어서,

    상기 제2 부분적 매핑으로부터의 적어도 하나의 할당을 상기 제1 부분적 매핑에 복사하는 단계(4008); 및

    상기 제1 부분적 매핑으로부터의 상기 적어도 하나의 할당을 상기 제2 부분적 매핑에 복사하는 단계(4012)

    중 적어도 하나를 더 포함하는 방법.
12. 제9항에 있어서, 상기 제1 부분적 매핑에 새로운 할당을 기입함과 동시에, 상기 새로운 할당을 상기 제2 부분적 매핑에 기입하는 단계(3808)를 더 포함하는 방법.
13. 데이터베이스에 지향되는 트랜잭션들을 관리하기 위한 컴퓨터 구현 방법으로서,

    트랜잭션이 개시되는 때의 상기 데이터베이스의 상태를 식별하는 단계(1204);

    상기 트랜잭션이 상기 데이터베이스에 기입하려고 시도하는 데이터를 버퍼에 저장하는 단계(1214);

    현 상태 포인터(120)가 포인트들(points)을 현 상태 내의 가장 최근에 삽입된 개체로 포인팅하도록 상기 데이터베이스의 현 상태로 포인팅하는 상기 현 상태 포인터를 유지하는 단계;

    상기 트랜잭션을 커밋하려고 시도함(2102)과 동시에, 상기 트랜잭션이 기입하려고 시도하는 데이터가 현 상태와 불일치한다는 지시(indication)를 찾는 단계(2104);

    상기 트랜잭션이 기입하려고 시도하는 데이터가 상기 현 상태와 불일치한다는 어떤 지시도 발견하지 못함과 동시에, 버퍼를 상기 현 상태로 포인팅하고 상기 현 상태 포인터를 가장 최근에 삽입된 개체로서의 버퍼로 포인팅함(2106)으로써 상기 트랜잭션을 커밋하는 단계

    를 포함하는 데이터베이스에 지향되는 트랜잭션들을 관리하기 위한 컴퓨터 구현 방법.
14. 제13항에 있어서, 상기 데이터베이스로부터 원하는 데이터를 찾는 단계를 더 포함하고,

    이 단계는,

    상기 현 상태 포인터(120)에 의해 지시된 상기 현 상태를 식별하는 단계; 및

    먼저 상기 원하는 데이터를 저장하는 개체를 발견하거나 또는 상기 현 상태가 상기 원하는 데이터를 저장하지 않는다는 것을 발견할 때까지 상기 현 상태 내의 각 개체에 연속하여 액세스하는 단계를 포함하는 방법.
15. 제13항에 있어서, 상기 트랜잭션이 기입하려고 시도하는 데이터가 상기 현 상태와 불일치한다는 지시는,

    상기 현 상태가 상기 트랜잭션이 개시된 때의 상기 데이터베이스의 상태와 다르다고 판정하는 단계(2904); 및

    상기 트랜잭션이 개시되었고 상기 현 상태가 개입 트랜잭션이 상기 트랜잭션에 의해 판독된 어드레스에 데이터를 기입한 것과, 상기 트랜잭션에 의해 판독된 어드레스에서 데이터를 변경한 것 중 적어도 하나를 행하였음을 나타낼 때 상기 현 상태가 상기 데이터베이스의 상태와 다르다고 판정하는 단계(2906)

    중 적어도 하나를 포함하는 방법.
16. 제13항에 있어서, 상기 현 상태 내의 복수의 개체들에 저장된 데이터를 합체 개체(coalesced object) 내로 합체하는 단계(3510)를 더 포함하는 방법.
17. 제16항에 있어서, 선택된 상태가 상기 선택된 상태 후에 상기 현 상태에 추가된 하나 이상의 개체들과 합체되지 못하게 함으로써 상기 데이터베이스의 상기 선택된 상태를 보전하는 단계(3508)를 더 포함하는 방법.
18. 데이터베이스에 지향되는 트랜잭션들을 관리하기 위한 컴퓨터 구현 방법으로서,

    상기 데이터베이스의 현 상태로의 현 상태 포인터(120)를 유지하는 단계;

    트랜잭션이 개시되는 때에 존재하는 상기 데이터베이스의 현 상태를 식별하 는 단계(1206);

    상기 트랜잭션에 대한 기입 버퍼를 생성하는 단계(1206);

    상기 트랜잭션이 상기 데이터베이스에 기입하려고 시도하는 데이터를 상기 기입 버퍼에 저장하는 단계(1214);

    상기 기입 버퍼를 상기 현 상태로 포인팅하는 단계(1206); 및

    상기 트랜잭션이 상기 데이터베이스에 커밋되면 상기 데이터베이스에 적용될 변경들의 부분적 매핑을 나타내기 위해 트랜잭션 포인터를 상기 기입 버퍼로 포인팅하는 단계(1208)

    를 포함하는 데이터베이스에 지향되는 트랜잭션들을 관리하기 위한 컴퓨터 구현 방법.
19. 제18항에 있어서, 상기 트랜잭션이 상기 데이터베이스에 추가 데이터를 기입하려고 시도하는 경우,

    추가 기입 버퍼를 생성하는 단계(1212);

    상기 추가 데이터를 상기 추가 기입 버퍼에 저장하는 단계(1212);

    상기 추가 기입 버퍼를 상기 기입 버퍼로 포인팅하는 단계(1214); 및

    상기 트랜잭션 포인터를 상기 추가 기입 버퍼로 포인팅하는 단계(1216)

    를 더 포함하는 방법.
20. 제18항에 있어서,

    상기 현 상태가 상기 트랜잭션이 개시된 때의 현존하는 상태와 여전히 동일한 상태를 유지하는 경우(2904)와;

    상기 트랜잭션이 개입 트랜잭션이 기입과 변경 중 적어도 하나를 행한 값을 판독하지 않았다면 상기 현 상태가 상기 개입 트랜잭션을 포함하도록 변경된 경우(2906)

    중 하나의 경우에 상기 트랜잭션을 상기 데이터베이스에 커밋하는 단계를 더 포함하는 방법.

Images