Abstract:
A method, apparatus, and system for a time-based checkpoint target is provided for standby databases. Change records received from a primary database are applied for a standby database, creating dirty buffer queues. As the change records are applied, a mapping is maintained, which maps timestamps to logical times of change records that were most recently applied at the timestamp for the standby database. On a periodic dirty buffer queue processing interval, the mapping is used to determine a target logical time that is mapped to a target timestamp that is prior to a present timestamp by at least a checkpoint delay. The dirty buffer queues are then processed up to the target logical time, creating an incremental checkpoint. On a periodic header update interval, file headers reflecting a consistent logical time for the checkpoint are also updated. The intervals and the checkpoint delay are adjustable by user or application.
Abstract:
Techniques are described herein for making a clean file snapshot of a target file. The techniques may be applied to a single target file, to a set of target files, or to an entire database The techniques involve transitioning the target file through a series of states. During each state, particular actions are performed and/or prevented. In the final state of each approach, a clean file snapshot of the target file exists. Transitioning through the states, only one of which does not allow new changes to be made to the target file, allows the database to remain online and available to a greater extent than is possible with an approach that prevents database changes for the duration of the clean file snapshot creation operation.
Abstract:
A pluggable database is transported between a source DBMS and a destination DBMS, in a way that minimizes downtime of the pluggable database. While a copy of the pluggable database is being made at the destination DBMS, transactions continue to execute against the pluggable database at the source DBMS and change the pluggable database. Eventually, the transactions terminate or cease executing. Redo records generated for the transactions are applied to the copy of the pluggable database at the source DBMS. Undo records generated for at least some of the transactions may be stored in a separate undo log and transported to the destination DBMS. The transported pluggable database is synchronized at a destination DBMS in a “pluggable-ready state”, where it may be plugged into the destination container DBMS.
Abstract:
A method, apparatus, and system for multi-instance redo apply is provided for standby databases. A multi-instance primary database generates a plurality of redo records, which are received and applied by a physical standby running a multi-instance standby database. Each standby instance runs a set of processes that utilize non-blocking, single-task threads for high parallelism. At each standby instance for the multi-instance redo, the plurality of redo records are merged into a stream from one or more redo strands in logical time order, distributed to standby instances according to determined apply slave processes using an intelligent workload distribution function, remerged after receiving updates from remote instances, and applied in logical time order by the apply slave processes. Redo apply progress is tracked at each instance locally and also globally, allowing a consistent query logical time to be maintained and published to service database read query requests concurrently with the redo apply.
Abstract:
In an embodiment, before modifying a persistent ORL (ORL), a database management system (DBMS) persists redo for a transaction and acknowledges that the transaction is committed. Later, the redo is appended onto the ORL. The DBMS stores first redo for a first transaction into a first PRB and second redo for a second transaction into a second PRB. Later, both redo are appended onto an ORL. The DBMS stores redo of first transactions in volatile SRBs (SLBs) respectively of database sessions. That redo is stored in a volatile shared buffer that is shared by the database sessions. Redo of second transactions is stored in the volatile shared buffer, but not in the SLBs. During re-silvering and recovery, the DBMS retrieves redo from fast persistent storage and then appends the redo onto an ORL in slow persistent storage. After re-silvering, during recovery, the redo from the ORL is applied to a persistent database block.
Abstract:
Herein is high availability for online transaction processing with redundancy and redo for a federation of pluggable databases and container databases. In a federation of container database management systems that includes a first container database, first redo data of a first pluggable database in a second container database is obtained based on a database dictionary in the first container database. To the first pluggable database in the first container database, the first redo data of the first pluggable database in the second container database is applied. Based on the database dictionary in the first container database, second redo data of a second pluggable database in a third container database is obtained. To the second pluggable database in the first container database, without modifying content of the first pluggable database in the first container database, the second redo data of the second pluggable database in the third container database is applied.
Abstract:
Techniques are described for preserving the inflight sessions failing over from a primary database to the replicated logical database of the primary database. In an implementation, prior to failover, when the primary database server receives a commit for a transaction, the process stores a commit indication that the transaction has been committed by performing a corresponding SQL command. The commit indication is replicated to the logical replica database by virtue of the replication of the SQL command and its execution on the logical replica database. Accordingly, the standby database server in the failover session may successfully request for the outcome of the transaction. Techniques are also described for the client-side LOB references to be preserved when failing over to the logical replica database, for AS OF queries preserved, and for versioning of checksums, signatures and structures across logical replicas.
Abstract:
An approach is described to provide a method, a computer program product, and a computer system to implement hole punching. The described approach provides an automated way to free up space without requiring manual intervention by a DBA to manually reorganize database objects to free up space.
Abstract:
In an embodiment, before modifying a persistent ORL (ORL), a database management system (DBMS) persists redo for a transaction and acknowledges that the transaction is committed. Later, the redo is appended onto the ORL. The DBMS stores first redo for a first transaction into a first PRB and second redo for a second transaction into a second PRB. Later, both redo are appended onto an ORL. The DBMS stores redo of first transactions in volatile SRBs (SLBs) respectively of database sessions. That redo is stored in a volatile shared buffer that is shared by the database sessions. Redo of second transactions is stored in the volatile shared buffer, but not in the SLBs. During re-silvering and recovery, the DBMS retrieves redo from fast persistent storage and then appends the redo onto an ORL in slow persistent storage. After re-silvering, during recovery, the redo from the ORL is applied to a persistent database block.
Abstract:
Techniques related to query execution against an in-memory standby database are disclosed. A first database includes PF data stored on persistent storage in a persistent format. The first database is accessible to a first database server that converts the PF data to a mirror format to produce MF data that is stored within volatile memory. The first database server receives, from a second database server, one or more change records indicating one or more transactions performed against a second database. The one or more change records are applied to the PF data, and a reference timestamp is advanced from a first to a second timestamp. The first database server invalidates any MF data that is changed by a subset of the one or more transactions that committed between the first and second timestamps.