Afrikaans
Akan
Albanian
Amharic
Armenian
Azerbaijani
Basque
Belarusian
Bemba
Bengali
Bihari
Bosnian
Breton
Bulgarian
Cambodian
Catalan
Cebuano
Cherokee
Chichewa
Chinese (Simplified)
Chinese (Traditional)
Corsican
Croatian
Czech
Danish
Dutch
English
Esperanto
Estonian
Ewe
Faroese
Filipino
Finnish
French
Frisian
Ga
Galician
Georgian
German
Greek
Guarani
Gujarati
Haitian Creole
Hausa
Hawaiian
Hebrew
Hindi
Hmong
Hungarian
Icelandic
Igbo
Indonesian
Interlingua
Irish
Italian
Japanese
Javanese
Kannada
Kazakh
Kinyarwanda
Kirundi
Kongo
Korean
Krio (Sierra Leone)
Kurdish
Kurdish (Soranรฎ)
Kyrgyz
Laothian
Latin
Latvian
Lingala
Lithuanian
Lozi
Luganda
Luo
Luxembourgish
Macedonian
Malagasy
Malay
Malayalam
Maltese
Maori
Marathi
Mauritian Creole
Moldavian
Mongolian
Myanmar (Burmese)
Montenegrin
Nepali
Nigerian Pidgin
Northern Sotho
Norwegian
Norwegian (Nynorsk)
Occitan
Oriya
Oromo
Pashto
Persian
Polish
Portuguese (Brazil)
Portuguese (Portugal)
Punjabi
Quechua
Romanian
Romansh
Runyakitara
Russian
Samoan
Scots Gaelic
Serbian
Serbo-Croatian
Sesotho
Setswana
Seychellois Creole
Shona
Sindhi
Sinhalese
Slovak
Slovenian
Somali
Spanish
Spanish (Latin American)
Sundanese
Swahili
Swedish
Tajik
Tamil
Tatar
Telugu
Thai
Tigrinya
Tonga
Tshiluba
Tumbuka
Turkish
Turkmen
Twi
Uighur
Ukrainian
Urdu
Uzbek
Vietnamese
Welsh
Wolof
Xhosa
Yiddish
Yoruba
Zulu
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.