Oracle Database Creation

 

MBRKAIS

D:\MBR-DBS-DATA\MBRKAIS\{DB_UNIQUE_NAME}

E:\MBR-DBS-DATA\MBRKAIS\FAST_RECOVERY_AREA\{DB_UNIQUE_NAME}

Click Advanced Configuration

D:\MBR-DBS-DATA\MBRKAIS

E:\MBR-DBS-DATA\MBRKAIS\FAST_RECOVERY_AREA\

Oracle Software Installation

Create a oracle home directory and extract downloaded oracle home setup to this folder location

 

D:\app\oracle\product\19.0.0\dbhome_1

Oracle base:

D:\app\oracle

 

Oracle Home (Software Location) :

D:\app\oracle\product\19.0.0\dbhome_1

Some oracle files come to given oracle base folder

```html

SELECT
    a.tablespace_name "TABLESPACE_NAME",
    ROUND(a.current_mb) "CURRENT SIZE(MB)",
    ROUND(a.max_mb) "MAXIMUM SIZE (MB)",
    ROUND(a.max_mb - (a.current_mb - c.free)) "FREE SPACE (MB)",
    ROUND(a.current_mb - c.free) "USED_MB",
    ROUND(((a.current_mb - c.free) * 100) / a.max_mb) "USED PCT%"
FROM
    (
        SELECT
            tablespace_name,
            SUM(a.bytes) / (1024 * 1024) current_mb,
            SUM(
                DECODE(
                    a.autoextensible,
                    'NO',
                    a.bytes / (1024 * 1024),
                    GREATEST(
                        a.maxbytes / (1024 * 1024),
                        a.bytes / (1024 * 1024)
                    )
                )
            ) max_mb
        FROM dba_data_files a
        GROUP BY tablespace_name
    ) a,
    (
        SELECT
            d.tablespace_name,
            SUM(NVL(c.bytes / (1024 * 1024), 0)) free
        FROM dba_tablespaces d,
             dba_free_space c
        WHERE d.tablespace_name = c.tablespace_name(+)
        GROUP BY d.tablespace_name
    ) c
WHERE
    a.tablespace_name = c.tablespace_name
ORDER BY
    ROUND(((a.current_mb - c.free) * 100) / a.max_mb) DESC;

```

Oracle Database Architecture

 

An Oracle Database consists of at least one database instance and one database. The database instance handles memory and processes. The multitenant container database consists of physical files called data files. An Oracle Database also uses several database system files during its operation.

A single-instance database architecture consists of one database instance and one database. A one-to-one relationship exists between the database and the database instance. Multiple single-instance databases can be installed on the same server machine. There are separate database instances for each database. This configuration is useful to run different versions of Oracle Database on the same machine.

An Oracle Real Application Clusters (Oracle RAC) database architecture consists of multiple instances that run on separate server machines. All of them share the same database. The cluster of server machines appear as a single server on one end, and end users and applications on the other end. This configuration is designed for high availability, scalability, and high-end performance.

The listener is a database server process. It receives client requests, establishes a connection to the database instance, and then hands over the client connection to the server process. The listener can run locally on the database server or run remotely. Typical Oracle RAC environments are run remotely.

The shared pool is a component of the System Global Area (SGA) and is responsible for caching various types of program data. For example, the shared pool stores parsed SQL, PL/SQL code, system parameters, and data dictionary information. The shared pool is involved in almost every operation that occurs in the database. For example, if a user executes a SQL statement, then Oracle Database accesses the shared pool.

The shared pool is divided into several subcomponents:

• Library cache: Is a shared pool memory structure that stores executable SQL and PL/SQL code. This cache contains the shared SQL and PL/SQL areas and control structures, such as locks and library cache handles. When a SQL statement is executed, the database attempts to reuse previously executed code. If a parsed representation of a SQL statement exists in the library cache and can be shared, the database reuses the code. This action is known as a soft parse or a library cache hit. Otherwise, the database must build a new executable version of the application code, which is known as a hard parse or a library cache miss.
• Reserved pool: Is a memory area in the shared pool that Oracle Database can use to allocate large contiguous chunks of memory. The database allocates memory from the shared pool in chunks. Chunking allows large objects (over 5 KB) to be loaded into the cache without requiring a single contiguous area. In this way, the database reduces the possibility of running out of contiguous memory because of fragmentation.
• Data dictionary cache: Stores information about database objects (that is, dictionary data). This cache is also known as the row cache because it holds data as rows instead of buffers.
• Server result cache: Is a memory pool within the shared pool and holds result sets. The server result cache contains the SQL query result cache and PL/SQL function result cache, which share the same infrastructure. The SQL query result cache stores the results of queries and query fragments. Most applications benefit from this performance improvement. The PL/SQL function result cache stores function result sets. Good candidates for result caching are frequently invoked functions that depend on relatively static data.
• Other components: Include enqueues, latches, Information Lifecycle Management (ILM) bitmap tables, Active Session History (ASH) buffers, and other minor memory structures. Enqueues are shared memory structures (locks) that serialize access to database resources. They can be associated with a session or transaction. Examples are: Controlfile Transaction, Datafile, Instance Recovery, Media Recovery, Transaction Recovery, Job Queue, and so on. Latches are used as a low-level serialization control mechanism used to protect shared data structures in the SGA from simultaneous access. Examples are row cache objects, library cache pin, and log file parallel write.