All language subtitles for 12_01-Instance Startup-en

af Afrikaans
ak Akan
sq Albanian
am Amharic
hy Armenian
az Azerbaijani
eu Basque
be Belarusian
bem Bemba
bn Bengali
bh Bihari
bs Bosnian
br Breton
bg Bulgarian
km Cambodian
ca Catalan
ceb Cebuano
chr Cherokee
ny Chichewa
zh-CN Chinese (Simplified)
zh-TW Chinese (Traditional)
co Corsican
hr Croatian
cs Czech
da Danish
nl Dutch
en English
eo Esperanto
et Estonian
ee Ewe
fo Faroese
tl Filipino
fi Finnish
fr French
fy Frisian
gaa Ga
gl Galician
ka Georgian
de German
el Greek
gn Guarani
gu Gujarati
ht Haitian Creole
ha Hausa
haw Hawaiian
iw Hebrew
hi Hindi
hmn Hmong
hu Hungarian
is Icelandic
ig Igbo
id Indonesian
ia Interlingua
ga Irish
it Italian
ja Japanese
jw Javanese
kn Kannada
kk Kazakh
rw Kinyarwanda
rn Kirundi
kg Kongo
ko Korean
kri Krio (Sierra Leone)
ku Kurdish
ckb Kurdish (Soranรฎ)
ky Kyrgyz
lo Laothian
la Latin
lv Latvian
ln Lingala
lt Lithuanian
loz Lozi
lg Luganda
ach Luo
lb Luxembourgish
mk Macedonian
mg Malagasy
ms Malay
ml Malayalam
mt Maltese
mi Maori
mr Marathi
mfe Mauritian Creole
mo Moldavian
mn Mongolian
my Myanmar (Burmese)
sr-ME Montenegrin
ne Nepali
pcm Nigerian Pidgin
nso Northern Sotho
no Norwegian
nn Norwegian (Nynorsk)
oc Occitan
or Oriya
om Oromo
ps Pashto
fa Persian
pl Polish
pt-BR Portuguese (Brazil)
pt Portuguese (Portugal)
pa Punjabi
qu Quechua
ro Romanian
rm Romansh
nyn Runyakitara
ru Russian
sm Samoan
gd Scots Gaelic
sr Serbian
sh Serbo-Croatian
st Sesotho
tn Setswana
crs Seychellois Creole
sn Shona
sd Sindhi
si Sinhalese
sk Slovak
sl Slovenian
so Somali
es Spanish
es-419 Spanish (Latin American)
su Sundanese
sw Swahili
sv Swedish
tg Tajik
ta Tamil
tt Tatar
te Telugu
th Thai
ti Tigrinya
to Tonga
lua Tshiluba
tum Tumbuka
tr Turkish
tk Turkmen
tw Twi
ug Uighur
uk Ukrainian
ur Urdu
uz Uzbek
vi Vietnamese
cy Welsh
wo Wolof
xh Xhosa
yi Yiddish
yo Yoruba
zu Zulu

Original subtitles

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.

Can't find what you're looking for?
Get subtitles in any language from opensubtitles.com, and translate them here.