0:06	hello everyone welcome back in this
0:08	presentation we will focus on instances
0:12	and schemas
0:13	these two are the important
0:15	terminologies as far as database
0:17	management systems is concerned in order
0:20	to understand things let's see an
0:22	analogy we know basically any software
0:25	is developed using some programming
0:27	languages so obviously software programs
0:29	are written who writes the software
0:31	program the programmer
0:34	let's assume a software programmer is
0:36	defining a variable a
0:38	so this variable is obviously going to
0:40	hold some value in it
0:42	now who is giving value to this variable
0:44	the software program that he has written
0:46	right and the value for this variable
0:48	will be existing within the scope of the
0:51	software program let's assume this
0:53	software program is modifying this
0:54	variable a as 20 now and it doesn't mean
0:58	that this 20 is always fixed to this
1:00	variable it may be changing according to
1:02	the situation so the variable a now it
1:05	is containing 20 the value of the
1:07	variable will be varying and that's why
1:10	it is named as variable
1:11	and what i mean to say here is a
1:14	software variable may contain any value
1:16	in it but what about the type of value
1:19	it is storing
1:20	it is actually storing integer type in
1:22	this example so if you note here the
1:24	variable a is declared as integer type
1:28	and let's assume this program is written
1:30	in c language
1:31	and let this variable be integer type so
1:34	when it is declared as integer in c
1:37	language the size of that variable is
1:39	going to be 2 bytes in other words 16
1:41	bits so what i mean to say here is the
1:44	value will be changed but the structure
1:47	and the memory that is assigned to this
1:49	variable a is fixed which is of 2 bytes
1:52	in nature so with this analogy let's
1:54	step into the topic of the day please be
1:56	noted that the value of the variable may
1:59	change but not the structure or the size
2:01	of the variable that is fixed here so
2:03	with this knowledge let's step into
2:05	seeing the definition of schemas what is
2:08	actually a schema it is actually the
2:11	overall design of the database what is a
2:13	database it is a collection of tables
2:16	what is a table it is a data structure
2:18	where the data is organized in the form
2:20	of rows and columns so when we have a
2:23	table and when we have collection of
2:24	tables we refer that as database and the
2:27	overall design or the structure of the
2:29	database is actually referred as schema
2:33	the overall design may involve multiple
2:35	tables say for example if we consider a
2:38	banking database it's not only one table
2:40	will be there in the banking database
2:42	tables like customer accounts loan
2:46	assets and many more should be
2:48	maintained in their banking database
2:50	any database we take we will have
2:52	multiple tables so the overall design or
2:55	the structure of the database is
2:57
referred as schema and how this is
3:00
related to the analogy that we have seen
3:02
so here the database schema is actually
3:04
referred as the variable declaration in
3:07
the analogy we have seen we have defined
3:09
the variable as integer which is of two
3:11
bytes when it is declared in c language
3:14
so the data type is integer and the size
3:16
of the data type is of two bytes because
3:18
we have declared it as integer in c
3:21
language so the variable declaration is
3:23
fixed
3:24
it may not be modified frequently it's
3:27
like the database schema so the database
3:29
schema is also like the variable
3:31
declaration where the schema is not
3:34
frequently changed but the data present
3:36
in the table may change but we are
3:38
talking about schemas so this schema is
3:41
like the variable declaration
3:43
so this is like the type definitions we
3:46
make in any programming languages that's
3:48
what we have seen in the analogy and
3:50
what about the changes or updations in
3:52
the schema will it be frequently done or
3:55
not at all or occasionally done once the
3:57
schema is fixed it's not frequently
3:59
changed and sometimes it's not at all
4:02
changed because the schema is actually
4:04
developed based on the requirement once
4:06
the schema is fixed it's not frequently
4:09
changed or even it is not at all changed
4:12
but there will be scope for changing and
4:14
that's why i related schema with the
4:17
variable declaration once a variable is
4:19
declared the size is fixed and it will
4:21
not be changed but there are some
4:23
dynamic memory allocation techniques in
4:25
any programming language to change the
4:27
data type but not frequently done anyway
4:30
if there is a requirement to change the
4:32
schema of course the database
4:33
administrator can change the schema i'll
4:36
show you an example type definition
4:38
which will help us to understand about
4:40
schemas so we are going to define a
4:42
record type of student here the record
4:45
type that i am creating is student and
4:47
what are all the fields that the student
4:49
record is going to contain the first one
4:51
the first field is the role number which
4:53
is of numeric type and the maximum size
4:56
is 5 the second field is the name of the
4:58
student which is of care type and the
5:00
maximum size of the student name is 25
5:02
characters and the last field is the
5:05
class in which the student is studying
5:07
and this class field is also off camera
5:09
type and the maximum size is 10 and we
5:12
are ending this if you note here this is
5:14
the structure that we have created this
5:16
is the student record which contains
5:18
three fields roll number name and class
5:21
so this structure is not frequently
5:23
changed
5:24
and that's why i told you schemas are
5:26
like the structure or the overall design
5:29
of the database now i will correlate
5:31
this with the real time example let's
5:33
take university as an example in a
5:35
university the department record or
5:37
table will contain columns or fields
5:39
like the department name the department
5:41
building the budget the name of the head
5:43
of the department and other fields
5:46
courses will contain fields like course
5:48
id title department name credits and so
5:51
on and the student record of student
5:53
table will contain fields or columns
5:55
like the roll number or the id name
5:57
department name total credits etc at the
6:00
physical level these tables or records
6:02
can be described as a block of some
6:04
consecutive storage locations and
6:07
obviously the system or the compiler
6:09
will hide all these level of details
6:11
from the programmers and that's what we
6:13
call as data abstraction it hides the
6:15
complexity because programmer doesn't
6:17
need all those internal details so the
6:20
database systems hides many of the
6:22
storage level details from the database
6:24
programmers on the other hand database
6:26
administrators will be aware of certain
6:28
additional details about the physical
6:30
organization of the database because he
6:32
is the database administrator
6:34
he has the complete control about the
6:36
database and he has additional
6:38
responsibilities so we are done with the
6:40
schemas let's now move on to the next
6:43
definition instances
6:45
and where we are going to talk about
6:46
this instances obviously in the
6:48
databases what is a database it's a
6:51
collection of interrelated data when we
6:54
say that it is a collection of
6:55
interrelated data and the collection of
6:58
the information stored in the database
7:00
at that particular moment is called as
7:02
an instance say for example databases
7:05
can change over time the data may be
7:08
added or the data may be deleted so the
7:11
database is the same but the data
7:13
present in the database is not the same
7:16
in all the instances i mean it's not the
7:19
same throughout isn't it so the data
7:22
present in the database may change and
7:24
that's why i said the collection of
7:26
information stored in the database at a
7:28
particular moment is referred as an
7:30
instance we know the structure of the
7:32
database will not be changed frequently
7:34
but the data present in the database
7:36
will be changed frequently let's assume
7:39
i'm maintaining a university database at
7:41
this particular time let's assume i have
7:44
1000 records maybe if 100 students are
7:47
admitted tomorrow then the database size
7:49
will be changed the data present in the
7:51
database will also be changed but the
7:53
structure is not changed frequently
7:54
isn't it so the collection of
7:57
information at that particular moment is
7:59
called as an instance and how this is
8:02
related to the analogy we have seen we
8:04
have seen the variable definition or the
8:06
type definition is equivalent to the
8:07
schema the value present in the variable
8:10
is equivalent to the instance so the
8:13	database instance means it's equivalent
8:15	to the value of the variable that we
8:17	have seen in the analogy because the
8:18	value of the variable keeps on changing
8:20	as per the need and obviously databases
8:23	can grow and shrink i hope now you are
8:25	clear with what is an instance what are
8:27	the three levels of abstraction we have
8:29	seen the view level logical level and
8:32	physical level likewise when we talk
8:34	about the schema and instances we should
8:37	be knowing that there exists subscribers
8:39	at the view level there exist multiple
8:41	views isn't it and then we have the
8:44	logical schema at the logical level and
8:46	then we have one more schema at the
8:48	bottom most level what's that
8:50	it's actually the physical schema where
8:52	the database actually reside it's
8:54	actually the database where the data are
8:56	actually stored in the physical medium
8:59	data how they are stored it is in the
9:01	physical schema how they are organized
9:04	in the application or in the language it
9:06	is done in the logical schema how it is
9:08	presented to the user and how many views
9:10	are there that is dealt in the sub
9:12	schema i hope now you can understand
9:14	what are schemas and instances i'll see
9:17	you in the next presentation and thank
9:19	you for watching
9:21	[Music]
9:21	[Applause]
9:23	[Music]