All language subtitles for 12_01-Instance Startup-en

In this lesson, we'll be taking
a look at Instance Startup,

or in the case of a
single-instance database as

opposed to a RAC, Instance
and Database Startup.

So the process of
startup involves

the database transitioning
between different states,

and each one of those
states, something different

occurs that's important to
the evolution of the startup

process.

And these different
states can actually

be controlled by the DBA.

So there are
situations in which we

want to start up
the database but we

want to stop at some
intermediary state

before we get to the final stage
where startup has completed.

And as the DBA, we
get to control that.

So it's important to understand
those different states.

So the first is
the NOMOUNT state.

So when we start
up the database,

the first state that's
entered is the NOMOUNT state.

And at that point, the
parameter file is read,

and so that reads all of the
Oracle Configuration parameters

into memory so that it knows
how to start the instance up.

Next, the memory is allocated.

So that memory in the operating
system is basically fenced off.

So if we have a 2 gigabytes
size of memory that's

been allocated, then the
operating system, essentially,

and Oracle takes that memory,
fences off that memory

for exclusive use by Oracle.

And then lastly, the background
processes are started.

So the PMON process and the SMON
and the checkpoint and the Log

Writer, and all of those
different processes

that do work are started.

So all of that occurs
during the first state

that Oracle enters
during a startup.

Next is the MOUNT state.

So at the MOUNT state, the
Control file is actually read.

So in the NOMOUNT state.

The Parameter file is read.

But in the MOUNT state,
which is the second state,

the Control file is read.

So the Control file knows where
all of the other data files

are, and then a lot
of different things--

even recovery information--
about the database,--

things like the system change
number and where the redo logs

are, the current log
sequence number--

all of those kinds of things.

So the Control file
is read at that point,

and so we could say
that the database knows

much more about itself
during the MOUNT state.

So the data files
become visible,

but they're not available.

That is to say, they're not
available to a user connecting

in who's attempting to
query data or change data.

But the data files do
become visible to the DBA,

and through a couple of
different data dictionary

views, we can look
at those data files.

And the reason for
that is the MOUNT state

is the recovery stage.

So when we need to do a
recovery from some kind of media

failure, we do so
in the MOUNT state.

And finally, the OPEN state--

the final state of start up.

So datafile integrity
is verified.

If any data files are missing--

so if someone has
dropped a data file

or there's a disk
error or something,

then the instance stays
in the MOUNT state.

But if everything is verified
and the integrity is there,

then the database becomes
made available to users.

And so users can connect in,
query against the database,

and then all of the
data is available.

So let's take a look at
some of these states.

We said that we
could control them.

So right now we have a
database that's shut down,

and let's just do a start up.

So notice, in our start up,
the steps that it went through.

So it says Oracle
instance started, and even

gives us the size of the
memory that's been allocated.

So that is the NOMOUNT state.

Parameter file is read.

The instance is started.

Memory's allocated.

Background processes
are allocated--

all in the NOMOUNT state.

Then the next message we get is
that the database is mounted.

So the Control
file has been read.

The data files are
visible but not available.

And then lastly, the
database is opened and made

available to users,
and now we could

connect in with a
database tool and do work.

And I'm going to
shut it down now.

And we'll go through
the different states.

So now the database
is shut down.

Exit out, here.

Clear the screen for
a little clarity.

And so we've connected
in, and it says

connected to an idle instance.

So that'll be the message that
we get when our database is

shut down, all right?

So it's idle.

There's nothing happening in it.

So let's go through the
different states one at a time.

So the first state
is NOMOUNT, and if we

want to enter any
individual state,

we simply type startup, and
then the name of the state.

So if we type
startup open, that's

the same thing as
typing a startup,

because it's going to
go through the NOMOUNT,

then the MOUNT,
then the open state.

So let's try just doing
a startup nomount.

All right, so we issued
a startup nomount,

and the message that we get is
that the instance is started,

and then it shows us the memory
allocation that was done.

No other messages, because
we're only in the NOMOUNT state.

No messages about being
mounted or anything like that.

So the parameter file was read.

The instance was allocated in
terms of memory and background

processes.

And we end the NOMOUNT state.

Now, if we wish to take the
database to the next state--

since we're in the
NOMOUNT state right now,

and we need to bring
it to the next--

we type alter database mount.

So here we've
mounted the database.

We've taken it to the next step.

So behind the scenes, the
Control file was read,

and all of the data
files were located.

So now we're in the MOUNT state.

If we wish to take it the rest
of the way to the OPEN state,

we say alter database open.

So now the database
has been taken manually

through each state--

NOMOUNT.

MOUNT, and OPEN-- and
is available for users.