An application container is an optional, user-created CDB component that stores data and metadata for one or more application back ends. A CDB includes zero or more application containers.
Within an application container, an application is the named, versioned set of common data and metadata stored in the application root. In this context of an application container, the term “application” means “master application definition.” For example, the application might include definitions of tables, views, and packages.
For example, you might create multiple sales-related PDBs within one application container, with these PDBs sharing an application that consists of a set of common tables and table definitions. You might store multiple HR-related PDBs within a separate application container, with their own common tables and table definitions.
CREATE PLUGGABLE DATABASE statement with the
AS APPLICATION CONTAINER clause creates the application root of the application container, and thus implicitly creates the application container itself. When you first create the application container, it contains no PDBs. To create application PDBs, you must connect to the application root, and then execute the
CREATE PLUGGABLE DATABASE statement.
CREATE PLUGGABLE DATABASE statement, you must specify a container name (which is the same as the application root name), for example,
saas_sales_ac. The application container name must be unique within the CDB, and within the scope of all the CDBs whose instances are reached through a specific listener. Every application container has a default service with the same name as the application container.
Purpose of Application Containers
In some ways, an application container functions as an application-specific CDB within a CDB. An application container, like the CDB itself, can include multiple PDBs, and enables these PDBs to share metadata and data.
The application root enables application PDBs to share an application, which in this context means a named, versioned set of common metadata and data. A typical application installs application common users, metadata-linked common objects, and data-linked common objects.
Key Benefits of Application Containers
Application containers provide several benefits over storing each application in a separate PDB.
The application root stores metadata and data that all application PDBs can share.
For example, all application PDBs can share data in a central table, such as a table listed default application roles. Also, all PDBs can share a table definition to which they add PDB-specific rows.
You maintain your master application definition in the application root, instead of maintaining a separate copy in each PDB.
If you upgrade the application in the application root, then the changes are automatically propagated to all application PDBs. The application back end might contain the data-linked common object
app_roles, which is a table that list default roles:
sales_rep, and so on. A user connected to any application PDB can query this table.
An application container can include an application seed, application PDBs, and proxy PDBs (which refer to PDBs in other CDBs).
You can rapidly create new application PDBs from the application seed.
You can query views that report on all PDBs in the application container.
While connected to the application root, you can use the
CONTAINERSfunction to perform DML on objects in multiple PDBs.
For example, if the
productstable exists in every application PDB, then you can connect to the application root and query the products in all application PDBs using a single
You can unplug a PDB from an application root, and then plug it in to an application root in a higher Oracle database release. Thus, PDBs are useful in an Oracle database upgrade.
Application Container Use Case: SaaS
A SaaS deployment can use multiple application PDBs, each for a separate customer, that share metadata and data.
In a pure SaaS environment, the master application definition resides in the application root, but the customer-specific data resides in its own application PDB. For example,
sales_app is the application model in the application root. The application PDB named
cust1_pdb contains sales data only for customer 1, whereas the application PDB named
cust2_pdb contains sales data only for customer 2. Plugging, unplugging, cloning, and other PDB-level operations are available for individual customer PDBs.
Figure 14-1 SaaS Use Case
Description of "Figure 14-1 SaaS Use Case"
A pure SaaS configuration provides the following benefits:
Support for multiple customers
The data for each customer resides in its own container, but is consolidated so that you can manage many customers collectively. This model extends the economies of scale of managing many as one to the application administrator, not only the DBA.
Application Containers Use Case: Logical Data Warehouse
A customer can use multiple application PDBs to address data sovereignty issues.
In a sample use case, a company puts data specific to each financial quarter in a separate PDB. For example, the application container named
q4_2016_pdb. You define each transaction in the PDB corresponding to the associated quarter. To generate a report that aggregates performance across a year, you aggregate across the four PDBs using the
Benefits of this logical warehouse design include:
ETL for data specific to a single PDB does not affect the other PDBs.
Execution plans are more efficient because they are based on actual data distribution.
An application container has exactly one application root, which is the parent of the application PDBs in the container.
The property of being an application root is established at creation time, and cannot be changed. The only container to which an application root belongs is the CDB root. An application root is like the CDB root in some ways, and like a PDB in other ways:
Like the CDB root, an application root serves as parent container to the PDBs plugged into it. When connected to the application root, you can manage common users and privileges, create application PDBs, switch containers, and issue DDL that applies to all PDBs in the application container.
Like a PDB, you create an application root with the
CREATE PLUGGABLE DATABASEstatement, alter it with
ALTER PLUGGABLE DATABASE, and change its availability with
SHUTDOWN. You can use DDL to plug, unplug, and drop application roots. The application root has its own service name, and users can connect to the application root in the same way that they connect to a PDB.
An application root differs from both the CDB root and standard PDB because it can store user-created common objects, which are called application common objects. Application common objects are accessible to the application PDBs plugged in to the application root. Application common objects are not visible to the CDB root, other application roots, or PDBs that do not belong to the application root.
Example 14-1 Creating an Application Root
In this example, you log in to the CDB root as administrative common user
c##system. You create an application container named
saas_sales_ac, and then open the application root, which has the same name as the container.
-- Create the application container called saas_sales_ac CREATE PLUGGABLE DATABASE saas_sales_ac AS APPLICATION CONTAINER ADMIN USER saas_sales_ac_adm IDENTIFIED BY manager; -- Open the application root ALTER PLUGGABLE DATABASE saas_sales_ac OPEN;
You set the current container to
saas_sales_ac, and then verify that this container is the application root:
-- Set the current container to saas_sales_ac ALTER SESSION SET CONTAINER = saas_sales_ac; COL NAME FORMAT a15 COL ROOT FORMAT a4 SELECT CON_ID, NAME, APPLICATION_ROOT AS ROOT, APPLICATION_PDB AS PDB, FROM V$CONTAINERS; CON_ID NAME ROOT PDB ---------- --------------- ---- --- 3 SAAS_SALES_AC YES NO
An application PDB is a PDB that resides in an application container. Every PDB in a CDB resides in either zero or one application containers.
For example, the
saas_sales_ac application container might support multiple customers, with each customer application storing its data in a separate PDB. The application PDBs
cust2_sales_pdb might reside in
saas_sales_ac, in which case they belong to no other application container (although as PDBs they necessarily belong also to the CDB root).
Create an application PDB by executing
CREATE PLUGGABLE DATABASE while connected to the application root. You can either create the application PDB from a seed, or clone a PDB or plug in an unplugged PDB. Like a PDB that is plugged in to CDB root, you can clone, unplug, or drop an application PDB. However, an application PDB must always belong to an application root.
An application seed is an optional, user-created PDB within an application container. An application container has either zero or one application seed.
An application seed enables you to create application PDBs quickly. It serves the same role within the application container as
PDB$SEED serves within the CDB itself.
The application seed name is always
application_container_name is the name of the application container. For example, use the
CREATE PDB ... AS SEED statement to create
saas_sales_ac$SEED in the
saas_sales_ac application container.