All language subtitles for [SubtitleTools.com] Pluggable Databases - Learning Oracle 12c [Video]

In this lesson, we're
going to take a look

at pluggable databases, or PDB.

Pluggable databases are a
core part of the Oracle 12c

Multitenant architecture.

Now Multitenant is a pay extra
option for the Oracle Database,

it doesn't come included.

But it has a number of
benefits that in many cases

can make it well
worth the extra cost.

The Multitenant architecture
allows for the virtualization

of databases.

So we have virtualization
in products like Oracle VM

and VMware that allow you
to virtualize servers,

a single small group
of physical servers

that can be virtualized to
hundreds of virtual servers.

And we can do the
same kinds of things

here with the Oracle 12c
Multitenant architecture

except we do them for databases.

It allows rapid provisioning
and cloning of databases.

So in the pluggable
architecture,

we have container databases.

And those containers contain
multiple pluggable label

databases.

So we can have an HR
database, CRM, order entry,

all of those types of things
as pluggable databases

within a container database.

What this allows us to do is
manage many databases as one.

So to a user's perspective,
they connect to the Order Entry

database, and they
see it just as

if it was a database on
a separate physical host.

But the truth is
they're actually

going through the PROD, or
production container database,

to the OE database.

That's actually a
pluggable database.

However, the DBA can manage all
of the plugging all databases

through the container database.

So this can be incredibly
efficient for a DBA

since they don't have
to individually manage

every one of the
pluggable databases.

So the benefits of
this architecture

include the patch
wants per CDB method.

So prior to Oracle 12c's
Multitenant architecture,

when a DBA wanted
to do patching,

say security
patching, they would

have to go to each
individual machine that

had an Oracle installation,
patch that software,

which would require the
database in most cases

to be down, causing an
outage for the organization,

and then do the patching
and then bring it back up.

But with the pluggable
build architecture,

we can patch once per
container database.

And that basically rolls down
to the pluggable databases

as well.

And this can be incredibly
beneficial in environments

where security is
of a high concern,

because Oracle releases
quarterly patches for security

updates.

And if those have to be
applied every quarter

in your organization,
you want to try

to limit the downtime for
patching as much as possible.

The pluggable architecture also
allows for quick provisioning.

So provisioning is a
term that's normally

applied to virtualization,
server virtualization

if you will that refers
to the act of allocating

a resource quickly and easily.

And we can do provisioning
with pluggable databases

very quickly for new databases.

In the pluggable
build architecture,

the container database
has a seed PDB,

or pluggable
database, by default.

So every container database
has a seed database.

Let's say we wanted to
make a quick allocation

or provisioning
of a new database.

All we would have to do is
clone that seed database.

Then we have a copy that's
ready for day to be loaded into

and to be operated on.

With a pluggable
architecture, we can also

do rapid cloning as well.

So we can clone PDBs
in seconds rather than

the time it would normally
take to make an entire copy.

And that usually would involve
creating another database,

exporting the data out
of the source database,

importing it into
the destination,

all of those kinds of things.

But with the pluggable
architecture,

we simply can clone
the PDB in seconds,

because all of those
basic resources, data,

information about the
database are already there

in the container.

So it can be easily cloned.

We can also clone databases
or PDB is between CDBs.

So if we had a requirement
to copy the production HR

database, in this case,
into a test environment,

if we were to do that
the old way prior to 12c,

we would have to create a
new database in the test

environment, export the
data from the source,

import into the destination,
so on and so forth.

But with this architecture, ,
we can easily clone that PDB

in seconds because all the
information is already there.

Another benefit for PDBs is
the ability to do migration.

And migration of
data between servers

can be a really difficult
thing to get a handle

on in a database environment,
because normally, it

would involve doing a
backup of the database,

moving all those files
over to the new server,

restoring that database,
all of those steps

that you would
have to go through.

But with the pluggable
architecture,

it's called pluggable because
we simply unplug a database

and plug it in somewhere else.

So we have an old
container database here,

and we want to migrate the
HR and CRM databases out

into a new container
database, which

might be on a different
server, different storage,

however our requirements
aligned for us to do this.

We simply unplug it, plug
it into the new container

database.

And all of this is done
with SQL statements.

There's no special tools used.

It's just SQL commands
that allow us to leverage

the pluggablee architecture.