Oracle Architecture Analysis

 

I. Oracle case

1. Oracle instances
System global area (SGA) and background process are used as database instances.

2. Oracle Database
A collection of physical files (data files, control files, online logs, parameter files, etc)

3. system global area (SGA)
System global area is a huge area of shared memory. It is regarded as a large buffer pool for Oracle databases. The data here can be shared by various Oracle processes. The size can be viewed using the following statement:
SQL> select * from V $ SGA;
NAME value
-----------------------------
Fixed size 39816
Variable Size 259812784
Database buffers 1.049e + 09
Redo Buffers' 327680

For more information, see V $ sgastat and V $ buffer_pool.

It mainly includes the following parts:

A. Shared Pool)
The shared pool is the most critical memory segment in SGA, especially in terms of performance and scalability. A small shared pool will stop the system, and a large shared pool will have the same effect, which will consume a lot of CPU to manage the Shared Pool. Improper use of the Shared Pool will only cause disasters. The sharing pool can be divided into the following two parts:
· Library Cache)
When a user submits an SQL statement, Oracle analyzes the SQL statement (PARSE). This process is similar to compiling and takes a relatively large amount of time. After the SQL statement is analyzed, Oracle saves the analysis result to the library cache of the Shared Pool. When the database executes the SQL statement for the second time, Oracle automatically skips the analysis process, this reduces the system running time. This is why the first SQL statement is slower than the second one.

The following example shows the time of parse.
SQL> select count (*) fromscpass;
Count (*)
----------
243
Elapsed: 00:00:00. 08
This is the time used when there is no data buffer in the performance_pool and data buffer.
SQL> alter system flush shared_pool;
System altered.

Clear performance_pool and keep data buffer
SQL> select count (*) from scpass;
Count (*)
----------
243
Elapsed: 00:00:00. 02
SQL> select count (*) from scpass;
Count (*)
----------
243
Elapsed: 00:00:00. 00

The time difference between the two SQL statements shows that the parse time of the SQL statement is about 00:00:00. 02.
SQL statements stored in the shared pool can be queried from V $ sqltext and V $ sqlarea. programmers should try to increase the statement reuse rate and reduce the statement analysis time. A poorly designed application can destroy the share pool of the entire database. To improve the Reuse Rate of SQL statements, you must first develop good habits and try to use bind variables as much as possible.

 

· Data Dictionary Cache)

Obviously, the data dictionary buffer is a buffer pool specially prepared by Oracle for data dictionary for internal use in Oracle. Nothing can be said.

B. Database buffer cache)
These buffers correspond to some used data blocks in all data files. Enable them to operate in memory. At this level, there are no system files, household data files, temporary data files, and rollback segment files. That is, data blocks of any file may be buffered. Any modification to the database is completed in the buffer, and the dbwr process writes the modified data to the disk.

The blocks in this buffer zone are basically managed in two different lists. One is the block's "dirty" table (dirty list), which needs to be written using the database block writer (dbwr), and the other is the non-dirty block list (Free List ), generally, the least recently used (least recently used, LRU) algorithm is used for management.
Block buffer high-speed cache can be subdivided into the following three parts (default pool, keep pool, recycle pool ). If the initialization parameter (init. ora) is not set manually, Oracle defaults to the default pool.

Due to the limitation of the addressing capability of the operating system, without special settings, on a 32-bit system, the maximum cache capacity of the block buffer can reach 1.7 GB. On a 64-bit system, the Maximum Cache size of a block buffer is 10 Gb.

C. redo log Buffer)

Redo the buffer of the log file. Any changes to the database are recorded in the buffer in order, and then written to the disk by the lgwr process. These modifications may be DML statements, such as (insert, update, delete), or DDL statements, such as (create, alter, drop, etc ).

The redo log buffer exists because the memory-to-memory operations are much faster than the memory-to-hard disk operations. Therefore, replaying the log buffer can speed up database operations, however, considering the consistency and recoverability of the database, the retention time of data in the redo log buffer is not long. Therefore, the duplicate log buffer is usually very small. The duplicate log buffer greater than 3 m does not have much practical significance.

D. Java program buffer (Java pool)

Java program zone. After Oracle 8i, Oracle added support for Java in the kernel. The program buffer is reserved for the Java program. If you do not need a Java program, you do not need to change the default size of the buffer.

 

E. large pool)

The name of a large pool is not because it is large, but because it is used to allocate large blocks of memory and process larger memory than the shared pool, which is introduced at 8.0.
The following objects use a large pool:
· MTS-allocate UGA in the large pool of SGA
· Parallel executeion of statements: allows the allocation of message buffers between processes to coordinate parallel query servers.
· Backup-used for RMAN disk I/O Cache

 

 

4. Background Process)

The background process is an Oracle program used to manage database read/write, recovery, and monitoring. Server process communicates with user process and exchanges data with user process. On Unix machines, the Oracle background process is relative to the operating system process. That is to say, an oracle background process starts an operating system process. On Windows machines, the Oracle background process is relative to the operating system thread, open the task manager and we can only see one oracle..

You can view background processes in Unix as follows:

PS-Ef | grep ora _
# Ps-Ef | grep ora _ | grep xcluat
Oracle 29431 1 0 Sep 02? 2: 02 ora_dbwr_sid
Oracle 29444 1 0 Sep 02? 0: 03 ora_ckpt_sid
Oracle 29448 1 0 Sep 02? 2: 42 ora_smon_sid
Oracle 29442 1 0 Sep 02? 3:25 ora_lgwr_sid
Oracle 29427 1 0 Sep 02? 0: 01 ora_pmon_sid

A. The Oracle system has five basic processes:
Dbwr (data file writing process)
Lgwr (Log File writing process)
SMON (system monitoring process)
Pmon (user process monitoring process)
Ckpt (Checkpoint Process, synchronous data file, log file, control file)

B. dbwr
Write the data in the modified data buffer to the corresponding data file.
Maintain an empty BUFFER IN THE SYSTEM
Here are several concepts that are prone to errors:
· After an update is submitted, dbwr writes the data to the disk and returns it to the user for submission.
· Dbwr will trigger the ckpt background process
· Dbwr does not trigger the lgwr Process
The above concepts are all incorrect.
Dbwr is a very underlying working process that writes data in the buffer zone to the disk in batches. It has almost nothing to do with the processes of any front-end users and is not controlled by them. We will discuss whether dbwr will trigger the lgwr and ckpt processes in the following sections.
The main conditions for dbwr operation are as follows:
· Dbwr timeout
· There are not many empty buffers in the system to store data.
· Ckpt process triggers dbwr and so on

C. lgwr
Write the data in the redo log buffer to the redo log file. lgwr is a process that must communicate with the foreground user process. When the data is modified, the system generates a redo log and records it in the redo log buffer. This redo log can be considered as a structure similar to the following:
SCN = 000000001000
Data Block ID
The object ID = 0801.
Data ROW = 02
Data after modification = 0011
At the time of submission, lgwr must write the data in the redo log buffer of the modified data to the log data file, and then notify the foreground process of successful submission, and the foreground process will notify the user. From this point, we can see that lgwr undertakes the task of maintaining system data integrity.
The main conditions for lgwr work are as follows:
· User submission
· 1/3 of the redo log buffers were not written to the disk
· A redo log buffer larger than 1 MB has not been written to the disk
· Timeout
· If the SCN Number of the data to be written by dbwr is greater than the scn number of the lgwr record, dbwr triggers lgwr writing

D. SMON
Work mainly includes
· Clear temporary space
· Complete system instance recovery at system startup
· Gathering free space
· Resume the transaction activity from a non-available File
· Recovery of instances of failed nodes in Ops
· Clear the OBJ $ table
· Reduce rollback segments
· Offline rollback segments

E. pmon
It is mainly used to clear invalid user processes and release resources used by user processes. For example, pmon rolls back unsubmitted jobs, releases locks, and releases the SGA resources allocated to failed processes.

F, ckpt
Synchronization of data files, log files, and control files requires the ckpt process to synchronize data files, log files, and control files due to the working principle of dbwr/lgwr. Ckpt updates the header information of the data file/control file.

The main conditions for ckpt operations are as follows:
· Log Switching
· When the database is shut down with the immediate, transaction, and normal options
· Determined based on the set values of the initial log_checkpoint_interval, log_checkpoint_timeout, and fast_start_io_target files
· User-triggered
Manual configuration is required for starting the following processes

G, Arch
When the database runs in archive mode, Oracle starts the arch process. When the redo log file is full, switch the log file, the old redo log file is copied to one/more specific directories/remote machines by the arch process. These replicated redo log files are called archive log files.

H. reco
Resolves faults in distributed transactions. Oracle can connect to multiple remote databases. Due to network problems, some things are pending. The reco process tries to establish communication with the remote server. When the fault is eliminated, the reco process automatically resolves all pending sessions.

I. service process server process

Service Process classification:

· Dedicated server process)
A service process corresponds to a user process

· Multitreaded server process)
A service process corresponds to multiple user processes and serves user processes in turn.

PGA & UGA
PGA = process Global Area
UGA = user Global Area
It stores user information such as user variables, permissions, stacks, and sorting spaces. For dedicated server processes, UGA is allocated in PGA. For multi-threaded processes, UGA is allocated in the large pool.

J. User Process

On the client, pass the user's SQL statement to the Service Process

 

5. A global concept throughout the database-System Change number (SCN)
System Change number, a serial number maintained by the system. It is automatically added when the system needs to be updated. It is an important indicator of maintaining data consistency and sequential recovery in the system.

A. the query statement does not increase the SCN. Even if an update occurs at the same time, the corresponding SCN in the database is different. This ensures the order of data recovery.

B. maintain data consistency. When a query is executed, it first obtains the current SCN number from the system, he checks each data row and its corresponding SCN number. Only those rows that are no larger than its SCN number can be retrieved from the buffer zone of the corresponding user data file, the Rows larger than the SCN number should be retrieved from the buffer of the rollback segment data file.

 

Instance analysis:

The following five rows are returned for a query:
ID name
------------------------
1. Shanghai
2 Beijing
3 gugangzhou
4 Shenzhen
5 hanzhou

User A starts running at and ends at. User B executes an update statement at, and updates the record whose ID is 2 to change Beijing to Tianjing. and submit. At this time, there will be no Tianjing record in the query of user. At, the SCN is N, and user B's update changes the system's SCN to n + 1. When user a queries the record with ID = 2, it finds that its SCN is greater than the start of the query. SCN, he will find the record with SCN = N in the data buffer of the rollback segment and return it.

 

Ii. Oracle Database

Oracle Database composition-a collection of physical operating system files. It mainly includes the following types.

1. Control File (the parameter file init. ora records the location of the control file)

The control file includes the following main information:
· Database Name, checkpoint information, and database creation Timestamp
· All data files, online log files, and archived Log File Information
· Backup information

With this information, Oracle will know which files are data files and what are the current redo log files. These are the basic conditions for system startup and running. Therefore, Oracle is the basis for running. It is impossible to start a file system without control. Control files are very important. Generally, multiple mirror copies are used to protect control files, or raid is used to protect control files. The loss of control files will complicate database recovery.
Control file information can be queried from V $ controlfile

2. Data File (detailed information of the data file is recorded in the control file)

You can view the data file as follows:

SQL> select name from V $ datafile;
Name
---------------------------------------------
/U05/DBF/Prod/system_01.dbf
/U06/DBF/Prod/temp_01.dbf
/U04/DBF/Prod/users_01.dbf
/U09/DBF/Prod/rbs_01.dbf
/U06/DBF/Prod/applsys_indx_01.dbf
/U05/DBF/Prod/applsys_data_01.dbf

 

From the above we can see that data files can be roughly divided into the following categories:

 

I. System data file (system_01.dbf)
Stores system tables and data dictionaries. Generally, user data is not stored, but user scripts, such as processes, functions, and packages, are stored in the data dictionary.
Glossary: Data Dictionary
A data dictionary is a system table or view that stores system information, including database versions, data file information, tables, indexes, and other segment information, system running status and other system-related information and user script information. The database administrator can query the data dictionary to understand the running status of oracle.

Ii. rollback segment file (rbs_01.dbf)
If the database modifies the data, the rollback segment must be used. The rollback segment is used to temporarily store the data before the modification (before image ). Rollback segments are usually placed in a separate tablespace (rollback tablespace) to avoid tablespace fragmentation. The data files contained in this tablespace are rollback data files.
Iii. Temporary data file (temp_01.dbf)

It mainly stores user sorting and other temporary data. Similar to the rollback segment, the temporary segment is also prone to tablespace fragmentation, and there is no way to open a temporary segment on a permanent tablespace, therefore, a temporary tablespace is required. The data files contained in the tablespace are temporary data files, which are mainly used for sorting operations that cannot be performed on the memory. We must specify a temporary tablespace for the user.

Iv. User data file (/applsys_data_01.dbf, applsys_indx_01.dbf)
User data is stored. Two types of common user data, general data and index data, are listed here. Generally, if conditions permit, you can consider storing them on different disks.

 

3. redo log files (online redo logs)

Any operations you perform on the database are recorded in the redo log file. Before learning about redo logs, you must understand the concepts of redo logs. redo log groups and redo log group members (Member). A database must have at least two log group files, after writing a group, write it to another group in turn. Each log group has at least one log member. Multiple log members in one log group are mirror-related, which is conducive to log file protection because log files are damaged, in particular, the current online log corruption has a huge impact on the database.
The switching process of online log groups is called switching. Note that switching logs in a database with poor optimization results may cause temporary suspension ". There are two possible cases of suspension:
· In the case of archiving, logs to be archived cannot be archived, and online logs must be reused.
· Check point events have not been completed (log switching causes checkpoints), and online logs need to be reused

The common methods to solve this problem are:

I. added a log group.

Ii. Increase the size of log file members

You can use v $ log to view the log group and V $ logfile to view the specific member files.

 

4. archiving log files
Oracle can run in two modes: Archive mode and non-archive mode. If you do not need the archive mode, of course, you will not have archive logs, but your system will not be a practical system, especially not for the production system, because you may lose data. However, in archive mode, in order to save all the modifications made by users, the system will save them into a series of continuous files after switching the redo log files and overwrite them, this file series is an archive log file.
Someone may say that archiving log files occupies a large amount of hard disk space. In fact, you are willing to waste some disk space to protect your data, are you willing to lose your data? Obviously, we need to ensure the security of our data. In fact, archiving does not occupy your disk space all the time. You can back up her to the tape, or delete all the log files before the last full backup.

 

5. initialize the parameter file
The initsid. ora or init. ora file may be located in different versions. In 8i, it is usually located under $ ORACLE_HOME/admin/<Sid>/pfile
The initialization file records the startup parameters of many databases, such as memory, control files, and number of processes. It is loaded when the database is started (when nomount is loaded). The initialization file records many important parameters, it has a great impact on the performance of the database. If you are not familiar with it, Do not rewrite it easily. Otherwise, the database performance may degrade.

6. other files

I. Password File
It is used to authenticate oracle users with sysdba permissions.

Ii. Log Files
· Alarm log file (alert. log or alrt <Sid>. ora)
Records Database startup, shutdown, and important error information. The database administrator should check this file frequently and respond to any problems. You can use the following SQL statement to find its path select value from V $ parameter where name = 'background _ dump_dest ';

· Background or user tracking files
The information written before a system process or user process error is generally not readable. You can use the tkprof tool of Oracle to convert it to a readable format. The path of the Tracing file generated by the system process is the same as that of the alarm log file, you can use the following SQL statement to find its path select value from V $ parameter where name = 'user _ dump_dest ';

 

Iii. Oracle Logical Structure

 

1. Table space)
Tablespaces are the basic logical structure of databases and a collection of data files. A tablespace can contain multiple data files, but a data file can only belong to one tablespace.

2. segment (segment)
Segments are the space occupied by objects in the database. Although the segments correspond to database objects one by one, the segments are from the perspective of database storage. A segment can belong to only one tablespace. Of course, a tablespace can have multiple segments.
Tablespaces and data files are one-to-multiple relationships in physical storage. tablespaces and segments are one-to-multiple relationships in logical storage, and segments are not directly related to data files. A segment can belong to multiple data files. You can specify the data file to which the segment can be extended.

Segments can be divided into the following four types:
· Data Segment)
· Index segment)
· Rollback segment)
· Temporary segment (temporary segment)

 

3. Range (extent)

There are many interpretations of extent translation, some of which are extended and some of which are usually translated into segments. There can be multiple intervals in a segment, which is a large storage space reserved for data at one time until the range is full, the database will continue to apply for a new reserved storage space, that is, the new interval, until the maximum number of partitions (max extent) of the segment or no available disk space can be applied.

In Oracle8i or a later version, theoretically a segment can have infinite intervals, but multiple intervals have an impact on Oracle performance. Oracle recommends that you distribute data in as few intervals as possible, to reduce Oracle management and head movement.

 

4. Oracle data blocks)

Oracle is the most basic storage unit, which is an integer multiple of the OS data blocks. Oracle operations are based on blocks. A single interval can contain multiple blocks (if the interval is not an integer multiple of the block size, Oracle actually expands to an integer multiple of the block size ).

 

5. introduction to basic tablespace

 

A. System tablespace

Mainly stores data dictionaries and base tables of internal system tables.
SQL statement used to view Data Dictionary
Select * From dict
View the SQL statements in the internal system table
Select * from V $ fixed_view_definition
DBAs must have a deep understanding of the data dictionary in the system table. They must prepare some basic SQL statements. Through these SQL statements, they can immediately understand the system status and database status, these basic SQL statements include
Remaining space of the system
System SGA
Status system wait
User Permissions
Current user lock
Buffer usage
We do not recommend that you rely too much on excellent database management tools such as OEM/quest when you become a DBA, because they are not conducive to your understanding of the data dictionary, SQL statements can manage almost all databases.
Reading a large number of writes is a notable feature of the tablespace.

 

B. Temporary tablespace.
Temporary tablespace, as its name implies, is used to store temporary data. For example, the temporary space for sorting operations will be released at the next system startup.

C. rollback segment tablespace

I. Role of rollback segments in the system
When the database performs update, insert, delete, and other operations, the new data is updated to the original data file, and the old data (before image) is put into the rollback segment, if data needs to be rolled back, you can copy the data from the rollback segment to the data file. To complete data rollback. When the system recovers, the rollback segment can roll back and forth data that is not committed to solve the system's persistent read.

When a rollback segment is written in large quantities, it is generally a small amount of reading. Therefore, we recommend that you separate the rollback segments from a single device (such as a separate disk or raid ), to reduce disk I/O contention.

Ii. How rollback segments work

· A rollback tablespace can be divided into multiple rollback segments.
· A rollback segment can store data of multiple sessions.

· The rollback segment is a circular data model.
Assume that the rollback segments are composed of four intervals. Their use order is interval 1, interval 2, interval 3, interval 4, interval 1. That is to say, intervals can be used cyclically. When intervals 4 to intervals 1, the sessions in range 1 have not ended. After intervals 4 is used up, interval 1 cannot be used up, in this case, the system must allocate an interval of 5 to continue serving other sessions.

We analyze the completion of an update statement.

① The user submits an update statement
②. Server process checks the memory buffer.

If the data block is not buffered, it is read from the disk.

I. If there is no valid memory space, dbwr is started to write the dirty buffer not written to the disk.

II. If there is a valid space, read

③. Update Data in the buffer

I. Apply for a rollback segment portal and write the old data as a rollback segment

Ii. Lock and update data

Iii. record the changes in the redo log buffer at the same time.

4. the user submits a commit statement.

I. SCN increased

Ii. Write the redo log buffer into the redo log file

Iii. User commit returned

Iv. Oracle Core

1. LRU algorithm and Data Buffer

We know that the file size of the Oracle database is much larger than that of the SGA in the memory area of Oracle. LRU is an algorithm to keep frequently-used data in the memory as much as possible. When the database needs a data buffer, it will find an idle buffer from the end of the LRU queue of the database buffer and read a data block, the database then places the buffer in the middle of the LRU queue. If the buffer is used by other programs, it will move to the queue head. If the buffer is not used by other programs, if it has not been modified, it will slowly move to the end of the LRU queue and eventually be considered as an empty buffer that is overwritten by other data blocks. Once this buffer zone has been modified, dbwr will remove it from the LRU queue and put it in the lruw Queue (also called the stolen buffer zone). Wait for dbwr to write them into data files in batches, then they connect their buffers to the end of the LRU queue for repeated work.

To improve the speed of hash algorithms, Oracle has adopted a large number of hash algorithms in its design. Here we will talk about the theoretical knowledge of hash algorithms, in the future, we will have a better understanding of oracle. Hash is a way of exchanging space for time. Assume that I have 1 million pieces of data stored in a queue. If I want to find a piece of data from it, I want to find it from the beginning. I need 1 million storage units, if I use the hash Method for storage, I divide the storage space into an array of 1000*2000, and Add 1 million data entries to the array according to the following rules:

1. Define a function so that each data entry corresponds to a value ranging from 0.

2. Store the row record in the array with the function return value as the Base Object

3. We call this function hash function f (ROW). The return value of the hash function is the hash value. The array is

Hash array hasharray [N] [M].

There are the following formulas:
Find a unused buffer in hasharray [F (ROW)] [?]
Hasharray [F (ROW)] [?] = Row;

In this way, when we need a row, we simply need to calculate the hash value of the row, and then find it in the hash array with the subscript hash value. That is, the simplest method can be quickly found.

For (I = 1; I <= 2000; I ++)
If (hasharray [F (ROW)] [I] = row) return;
Next

Of course, the hash algorithm is still very complex. Here is just the simplest example. If you are interested, you can refer to the relevant data structure, which is not detailed here.

2. latch (Oracle internal lock)

Many people ask me the difference between latch and lock. latch is the internal lock of Oracle, which is responsible for more small internal reads and writes. For example, Oracle needs to write user updated data into the buffer zone, at this time, Oracle will add latch to the buffer zone to prevent dbwr from writing it to the disk, because without this latch, dbwr will write half of the useless data to the disk.

5. FAQs

1. What is the relationship between the instance and Sid?

What is Sid? In Oracle, Sid is a common variable, such as the Environment Variable oracle_sid and the initialization file initsid. ora. What is Sid? In fact, Sid is the identifier of the Oracle instance. Different Sid corresponds to different memory buffers (SGA) and different background processes. In this way, we can have multiple Sid database instances on a physical server.

2. What is the relationship between Oracle databases and instances?

A database is composed of physical files and instances that access data files. When an instance accesses a data file, the database is called a single-node database. This is the most common database format we see. Of course, there is also a multi-node database, that is, more than one instance accesses a database (or accesses a group of data files) together to provide better stability and parallel processing capabilities. This is called OPS (Oracle Parallel Server) in 8i and RAC (real application cluster) in Oracle9i ). In this database. Two or more instances are on different servers, and all ORACLE data files are on the shared disk array. instances on multiple servers can work simultaneously, they communicate through an internal network. If one server cannot provide services, the other server will take over its work, especially in key services.

3. Is there any uncommitted data in the data file of the running database?

This is possible because the data in user data files is written by dbwr, which is a very underlying background process and is not responsible for interaction with users. User interaction is completed by lgwr.

4. in question 3, if data is not written, will the data integrity be damaged when the machine suddenly loses power?

No, because the database integrity is guaranteed by lgwr, and Oracle ensures that any modifications made to the data file written by dbwr have been recorded in the redo log file. When the system starts again, you can read the redo log file to know that the data is not submitted. At this time, Oracle will automatically roll back the data. Therefore, the damage to the online log, especially the damage to the current online log, has a huge impact on the database and may lead to Incomplete Database.

5. Will data be lost if the data file is damaged?

So far, if you have backups and archives, you won't. Because all data modification records are recorded in the redo log, data will not be lost, you only need to restore the previous backup and archive log files and the current online redo log to restore all data.

6. Will data be lost if the online redo log is damaged?

As mentioned above, online logs are very corrupt to the database, so not only data may be lost, but also the database may not be synchronized. All commit records in the redo log will be lost, which is why Oracle needs to mirror online redo log files. Any data loss is not allowed.

7. Can I specify not to write a rollback segment in the transaction?

No. Writing rollback segments are the foundation for Oracle to ensure consistent read and transaction consistency. The rollback segment is a high-write segment. We recommend that you put it on a separate device.
For DDL statements such as drop and truncate, you can not write rollback segments (no undo information). Therefore, we recommend that you use the truncate table method to delete the entire table if the data volume is large.

It is not possible to write online logs. However, in some specific operations, few online logs can be written. For example, create table tablename as select to create a table using nologging, or insert data to the table in append mode, or load data directly.

 

 

 

Vi. Summary

 

Here, we understand the relationship between instances and databases. A database can have multiple instances, but one instance cannot correspond to multiple databases. In general, we use a single-node database, that is, an instance corresponds to only one database.

We understand the composition of Oracle instances, including memory and background processes, further explain the composition of SGA and the role of SGA, and analyze the advantages of statement reuse. Dbwr and lgwr are important in background processes. dbwr is an underlying background process controlled by Oracle, and lgwr is responsible for interaction with users.

In the Oracle database, we have elaborated on the physical and logical structure of the database. In the physical structure, pay attention to the following four types of files: control files, online logs, data files, and parameter files. In the logical structure, you need to understand the relationship between each logical structure. The order from large to small is as follows: The tablespace is a segment or a range.

Finally, we briefly describe the core content of the two Oracle databases, including the LRU algorithm and latch algorithm, and briefly describe the related content of the hash algorithm. For more information about Oracle, see related documents.