Study And Overview Of Object Oriented Database Computer Science Essay Free Essay Example

With the promotion of informations mold, the development of the object oriented paradigm brought a important alteration in how we look informations and the processs that operate on informations. Previously informations and their dealingss were stored in a database and processs were stored in an application plan. But with the development of the object oriented impression, we began to unite entity ‘s processs with the informations. As a consequence, entities became self contained units and can be reused and moved around with considerable easiness.

Restrictions of Relational Database

Relational databases represent informations as if they are organized in a planar tabular array. With the coming of SQL, a standard linguistic communication for accessing information was established. RDBMS had both logical and physical construction and performed good on many concern applications. Unlike the object oriented attack, the basic attack of the relational theory was that, informations and the plans that use it were independent of each other. This was and is the cardinal difference between the two attacks.

However the relational theory suffered many restrictions:

Object individuality:

Entities in a relational theoretical account gave no independent being. In the relational theory objects can merely be identified and accessed indirectly through the designation of those properties which characterize them.

Explicit relationships:

In the relational attack the individualities of relationships have no expressed representation. Here dealingss are recovered by put to deathing query operations on the database. Besides this, in the relational theoretical account, there are concealed semantics. See the undermentioned illustration:

In the above diagram, the Appraisal relation, and besides the Appraiser and Appraise functions are hidden.

Besides, sing the above illustration, the relationship becomes a relation linking two other dealingss. Therefore the difference between an entity and a relation is rather blurred.

Structured Data Objects:

The first normal signifier demands that the values for properties in a tuple must be atomic. But in some instances we need to see properties which are complex, where values of spheres are themselves tuples.

EName

EmpID

DOB

Address

Sexual activity

Appellation

Supervisor ID

Department

FirstName

MiddleName

LastName

Street

City

State

Pincode

Besides this, relational theoretical account besides restricts collection-types, such as sets, lists and multi-sets. This can be explained with the undermentioned illustration:

Department

DepartmentName

DepartmentNo

SupervisorID

DepartmentLocations

Computer Consultancy

06

2638999

{ Kolkata, Mumbai, Bangalore, Kochi }

Administration

01

8282928

{ Delhi, Chennai, Kolkata }

Human Resource

05

3683938

{ Singapore, UK, Mumbai }

Generalization and Inheritance

The entities that we model frequently follow a natural hierarchal construction. Relational databases have no range for showing this construct of hierarchy. Besides, heritage is non a portion of the relational theoretical account.

Methods

In a relational theoretical account, for entering explicitly particular questions on a database like for read-only questions, we require to make positions. This nevertheless introduces overhead as the system needs to keep the current value. Besides, for updating values, there is no mechanism available in the relational theoretical account. These are maintained outside the relational theoretical account.

Before we groove into deeper constructs, we foremost discourse here some basic constructs. There are many existent life applications, where RDBMS works rather successfully – and singular good DBMS bundles are besides available. Two really popular open-source RDBMS merchandises – MySQL and PostgreSQL are rather successfully running in existent life applications. However there are state of affairss where we require something more than what RDBMS gives us. This is why we require ODBMS. We would now discourse when to utilize ODBMS. We use ODBMS when:

We are utilizing embedded DBMS Applications: Applications which require super-fast response clip, we by and large seek embedded DBMS. In such instances use of RDBMS involves much overhead due to object-relational function and requires greater disposal support during the deployment of updated category strategies to the installed bases. Use of Java or DOT NET in such instances could be wise since they require a ego contained, non-intrusive and easy to deploy continuity solution.

Complex object relationship: Some applications involve complex information constructions, where categories define multiple cross mentions among themselves. This is hard to pattern in a RDBMS. In RDBMS, relationships in objects are dealt utilizing the construct of foreign keys. On the contrary, most ODBMSes induces reachability continuity i.e. if object A mentions object B, and object A is relentless, so object B becomes relentless automatically. This reachability is handled by the ODBMS engine thereby keeping the inside informations of the mentions when objects are stored and associating them up when objects are fetched.

Changing informations constructions: In certain applications, there are opportunities where new informations members or object dealingss are added. This state of affairs is really hard to manage in RDBMS, where the scheme and the question codification needs to be modified to suit in the needed alterations. ODBMS on the other manus let this as we can blend the old and new objects in the database with easiness and convenience.

While utilizing deep object constructions: Often it is required to form informations in signifier of graphs or trees. A really deep tree construction presents a drawn-out parent, kid, grandchild to the coder and is really hard to manage it in RDBMS. On the contrary, ODBMS can manage such instances utilizing reachability continuity as explained before, where the coder has to command to bring or hive away single branchlets, a subdivision or the whole tree ; unity being preserved the DB engine.

We are programming in an OO Language: While programming in OOL, it is preferred to utilize ODBMS alternatively of RDBMS particularly when multiple applications entree the same database. This is because if we use RDBMS, we need to compose codification to go through back and forth row objects fetched from the database and existent objects in our applications. Besides, we have to compose interlingual rendition codification for object-schema function and that excessively necessitate to be synchronized in all different applications. On the other manus, by utilizing ODBMS, the entree is same from all applications since the applications that are stored and fetched are manipulated in the same manner.

When objects include Collections: There might be certain applications that have members like a List, or a Set. A aggregation within an object by and large represents a one-to-many relationship. If we try to pattern this utilizing RDBMS, we would necessitate an intermediate tabular array that links up the parent object and the objects in the aggregation ; whereas in ODBMS we fetch and store the parent along with its member aggregation with a individual call.

The development squad uses Agile methodological analysis: Most developments today use nimble engineering. An ODBMS tantrums more swimmingly in agile development than RDBMS. Harmonizing to Scott Ambler, nimble methodological analysiss uses refactoring, agile mold, continual arrested development testing, constellation direction and separate sandboxes for developers to work in. RDBMS complicates such things due to proficient and cultural electric resistance mismatch, and the current deficiency of tool support. ODBMS make it easier to be nimble.

Data entree is through pilotage instead than question: Let us conceive of the instance when we need to entree informations in a extremely networked construction. In RDBMS, we do so by merely firing a series of SQL SELECT statements, whereas in ODBMS, pilotage through such constructions is chiefly done utilizing the native linguistic communication ‘s concepts, thereby doing the codification simpler to understand.

Need for Complex Datatype

Traditional database applications use conceptually simple informations types in information processing. But in recent old ages, complex informations types gave grown more of import. Complex information types have grown more of import in recent old ages. For illustration, as we had shown before that Addresses can be viewed as a individual twine, separate properties for each portion or complex properties which are non in the first normal signifier. Besides, it is frequently convenient to hive away multivalued properties as-is, without making a separate relation to hive away the values in first normal signifier.

Complex information finds it application in computer-aided design, computing machine aided package technology and multimedia and image databases. With complex datatypes and object orientation, we can stand for E-R theoretical account constructs, like individuality of entities, multivalued properties, and generalisation and specialisation straight, without a complex interlingual rendition to the relational theoretical account.

Collection and Large Object Types

There are four types of LOB ( Large OBjects ) :

CLOB: The character LOB object which is used to hive away character informations.

NCLOB: The National character set LOB type which is by and large used to hive away multiple byte character informations like Non-English characters.

Blob: It is used to hive away binary informations ; hence called binary LOB.

BFILE: A binary file stored outside of the database in the host operating system file system, but accessible from database tabular arraies. BFILEs can be accessed from your application on a read-only footing.

The LOB can hive away up to 128 TBs of informations and a tabular array can hold multiple LOB columns. A LOB consists of two parts:

The LOB Locator: A arrow that specifies the location of the LOB informations.

The LOB informations: The existent character or byte informations stored in the LOB.

Depending upon the size of the informations stored in a CLOB, NCLOB or BLOB, the information is stored either inside or outside the tabular array. If the information is less than 4KB, it is stored in the same tabular array, else it is stored outside. Now consider the following piece of codification:

CREATE TABLE CLOB_EXAMPLE {

ID INTEGER PRIMARY KEY,

CLOB_CONTENT CLOB NOT NULL

} ;

CREATE TABLE BLOB_EXAMPLE {

ID INTEGER PRIMARY KEY,

BLOB_CONTENT CLOB NOT NULL

} ;

CREATE TABLE BFILE_EXAMPLE {

ID INTEGER PRIMARY KEY,

BFILE_CONTENT CLOB NOT NULL

} ;

The above three codification snippings, creates three tabular arraies CLOB_EXAMPLE, BLOB_EXAMPLE and BFILE_EXAMPLE. We now see how to dwell the CLOBs and BLOBs with informations. We now fire the INSERT statement to dwell the tabular arraies CLOB_EXAMPLE and BLOB_EXAMPLE as shown:

INSERT INTO CLOB_EXAMPLE ( ID, CLOB_CONTENT ) VALUES ( 1, TO_CLOB ( ‘Daily I Always Remember You ‘ ) ) ;

INSERT INTO BLOB_EXAMPLE ( ID, BLOB_CONTENT ) VALUES ( 1, TO_BLOB ( ‘100010010110110 ‘ ) ) ;

In both the above instances, we have used the TO_CLOB to change over a text to a CLOB and TO_BLOB to change over the Numberss to a BLOB. For modifying values, we may compose:

Update CLOB_EXAMPLE

SET CLOB_CONTENT = TO_CLOB ( ‘Jack and Jill went up the Hill ‘ )

WHERE ID = 1 ;

Update BLOB_EXAMPLE

SET BLOB_CONTENT = TO_BLOB ( ‘11111100000001100101 ‘ )

WHERE ID = 1 ;

Oracle Multimedia uses LOBs to make datatypes that could be used for multimedia application such as Multimedia ORDAudio, ORDDoc, ORDImage, and ORDVideo. Oracle Multimedia uses the database substructure to specify object types, methods, and LOBs necessary to stand for these specialised types of informations in the database.

Collection Types and Structured Types

Collection types represents aggregation of elements like basic type, structured type or another aggregation type or arrays and are mapped into Oracle VARRAY and nested table types. We can make new or edit bing aggregation types.

Structured types on the other manus may be defined as user defined informations types that have attribute and methods. Methods enable us to specify behaviours for structured types. Structured types can besides be portion of a supertype and subtype heritage hierarchy. A structured type can be defined based on a basic information type, a distinguishable type, another structured type, or a mention to structured type or it can be defined as a aggregation type.

Structure types can be declared as follows:

create type Department as

( DNo varchar ( 5 ) ,

Dname varchar ( 10 ) ,

DLocation varchar ( 20 ) )

create type Employee as

( EmployeeID figure,

EmployeeName varchar ( 20 ) ,

EmployeeAddress varchar ( 50 ) ,

DateOfJoining day of the month,

section Department )

create table employee of Employee

The first statement defines a type called Department, which has three constituents: a figure, a name and a location. The 2nd statement defines a structured type Employee, which contains an ID, a name, reference, day of the month of connection and a section ( of type Department ) . These types referred above are called structured types. And eventually, a table employee incorporating tuples of type Employee is created.

A structured type can besides hold methods defined on it. We declare methods as portion of the type definition of a structured type:

create type Employee as

( EmployeeID figure,

EmployeeName varchar ( 20 ) ,

EmployeeAddress varchar ( 50 ) ,

DateOfJoining day of the month,

salary whole number,

section Department )

method calculateSalary ( noOfDaysWorked whole number )

Subsequently we define the method organic structure individually as:

create method calculateSalary ( noOfDaysWorked whole number ) for Employee

Begin

set ownSalary = ( noOfDaysWorked * wagePerDay )

terminal

Data Definition

An object oriented database comprises of objects and object categories linked via a figure of abstraction mechanisms. We will now discourse a small on objects, object categories and the abstraction mechanisms:

Objects

Normally in a relational information theoretical account, two indistinguishable tuples or rows basically refer to the same object. Therefore, relational theoretical account were typically referred to as value-oriented theoretical account. This was overcome in the object oriented informations theoretical account where two indistinguishable records can mention to two distinguishable objects via the impression of a alone system generated identifier.

An object may be redefined as a bundle of informations and processs. The properties of the object contain the information and the object ‘s methods define the processs. Methods are activated by messages passed between objects.

All objects besides posses the belongings of encapsulation. This is the procedure of boxing together of both informations and procedure within a defined interface and controlled entree across that interface. Encapsulation is inexplicit in the definition of an object since all use of objects must be done via defined processs attached to objects.

Object categories

An object category is nil but grouping of similar objects. It is used to specify the properties, methods and relationships common to a group of objects. Besides, we know that objects are cases of some category and hence they possess the same properties and methods.

Abstraction

We had already discussed in the relational database design chapter the importance of the abstract mechanism generalisation and besides discussed antecedently the function of collection in informations mold.

Generalization allows us to declare certain object categories as subclasses of other object categories. For case, as already cited in the old chapters, that Engineer, Secretary and Technician might wholly be declared subclasses of an Employee category. Collection on the other manus, is the procedure by which a higher degree object is used to group together a figure of lower-level objects. For case, a batch entity might be built up of an assembly of participants.

Inheritance

The generalisation hierarchy associates with it the thought of the procedure of heritage. There are two major types of heritage: structural heritage and behavioural heritage.

In structural heritage a subclass is said to inherit the properties of its superclass. Hence, suppose an employee category has properties name, reference, salary, so a subclass such as applied scientist will besides be defined by such properties. In behavioural heritage a subclass is said to inherit the methods of its superclass. Hence, if the employee category has a method calculatePay, so a subclass such as director will besides be characterized with this method.

A subclass besides inherits engagement in the relationship sets in which its superclass participates. A subclass may itself hold further subclasses specified on it ; it so forms a hierarchy or a lattice. If in a hierarchy, a given entity set is involved as a lower-level entity set in merely one ISA relationship so the entity sets have merely individual heritage.

Figure 14.1: Single Inheritance

If an entity set is a lower-level entity set in more than one ISA relationship, so the entity set has multiple heritage, and the resulting construction is said to be a lattice. In a lattice or hierarchy, a subclass inherits attributes non merely of its direct superclass, but besides of all its predecessor super categories. A subclass with more than one superclass is called a shared subclass. All of the superclass – subclass relationships we have seen therefore far have a individual superclass. A shared subclass is subclass in more than one distinguishable superclass – subclass relationships, where each relationship has a individual superclass ( multiple heritage ) .

Figure 14.2: Multiple Inheritance

Inheritance can be implemented at the degree of types or at the degree of tabular arraies. We will discourse them one by one.

With multiple heritage a category may hold more than one superclass. The class/subclass relationship is represented by a directed acyclic graph ( DAG ) . This is peculiarly utile when objects can be classified in more than one manner which are independent of each other.

Type Inheritance

To explicate type heritage let us foremost see the type definition for employee:

create type Employee as

( EmployeeID figure,

EmployeeName varchar ( 20 ) ,

EmployeeAddress varchar ( 50 ) ,

DateOfJoining day of the month )

Let us say that we want to hive away some excess information in the database about employee who are applied scientists, secretaries and technicians. Since applied scientists, secretaries and technicians are besides employee, we can utilize heritage to specify the applied scientist type, secretary type and technician types.

create type Engineer

under Employee

( EngType varchar ( 10 ) )

create type Secretary

under Employee

( TypingSpeed varchar ( 10 ) )

create type Technician

under Employee

( TGrade varchar ( 10 ) )

All the three i.e. applied scientist, secretary and technician inherit the properties of Employee – i.e. ID, name, reference and day of the month of fall ining. Engineer, secretary and technician are said to be subtypes of Employee and Employee is a supertype of applied scientist, secretary and technician.

Methods of a structured type are inherited by its subtypes, merely as properties are. But, a subtype can redefine the consequence of a method by declaring the method once more, utilizing overruling method in topographic point of method in the method declaration.

The above illustration cited supra is an illustration of individual heritage. We would besides mention an illustration of multiple heritage.

Multiple heritage allows a category to inherit from multiple categories. See the illustration of a category named Performer to inherit from a category named Vocals, a category named Guitarist, and a category named Drummer.

Musician

Drummer

Guitarist

Vocal musics

Performer

Figure 14.3: Type heritage for Multiple heritage

Let us now define the Human category as follows:

create type Musician as

( Name varchar2 ( 10 ) ,

DateOfBirth day of the month,

Age whole number,

Address varchar2 ( 50 ) )

We now define Person, Musician and Worker as follows:

create type Vocal musics

under Musician

( Sexual activity char ( 1 ) ,

salary whole number,

Type varchar2 ( 50 ) )

method sing ( )

create type Guitarist

under Musician

( GuitarStyle varchar2 ( 10 ) ,

salary whole number )

method playGuitar ( )

create type Drummer

under Musician

( DrumType varchar2 ( 10 ) )

method playDrums ( )

Now we would demo how to implement the type Performer, which involves multiple heritage. Performer can be implemented as:

create type Performer

under Vocal musics, Guitarist, Drummer

Performer would inherit all the properties of Vocal musics, Guitarist and Drummer. In SQL as in most other linguistic communications, a value of a structured type must hold precisely one “ most-specific type. ” That is, each value must be associated with one specific type, called its most-specific type, when it is created.

Table Inheritance

In the old subdivision, we have defined type heritage. Here we will discourse table heritage. For illustration, we define the employee tabular array as:

create table employee of Employee

We now define the tabular arraies Engineer, Secretary and Technician as sub-tables of employee, as shown below:

create table applied scientist of Engineer

under employee

create tabular array secretary of Secretary

under employee

create table technician of Technician

under employee

The types of the sub-tables must be subtypes of the type of the parent tabular array. Thereby, every property nowadays in employee is besides present in the sub-table. Further, when we declare engineer, secretary and technician as sub-tables of employee, every tuple nowadays in applied scientist, secretary or technician is implicitly present in employee.

Multiple heritage is possible with tabular arraies, merely as it is possible with types. See the followers as follows:

create table performing artist of Performer

under Vocal musics, Guitarist, Drummer

As a consequence of the declaration, every tuple nowadays in the performing artist tabular array is besides implicitly present in the Vocal musics, Guitarist and in the Drummer tabular array, and in bend in the Musician tabular array. It is notable to advert that tuples in a sub-table corresponds to tuples in a parent tabular array if they have the same values for all familial properties. But, each tuple of the super tabular array can match to at most one tuple in each of its immediate sub tabular arraies.

Object individuality and Reference types

An object retains its individuality even if some or all of the values of variables or definitions of methods alteration over clip. Object individuality is a stronger impression of individuality than in programming linguistic communications or informations theoretical accounts non based on object orientation. This comprises of:

Value – This is data value such as primary cardinal value used in relational systems.

Name – These are supplied by user and are used for variables in processs.

Built-in – It is identity built into informations theoretical account or programming linguistic communication. No user supplied identifier is required and it is the signifier of individuality used in object oriented systems.

Object identifiers

Object identifiers are used to unambiguously place objects. Object identifiers are normally alone and non two objects have the same identifier. Each object has merely one object identifier. As for illustration, Depandant_Parent field of a individual object may be an identifier of another individual object. It can be stored as a field of an object to mention to another object. It can be system generated or external, such as social-security figure. System generated identifiers are easier and convenient to utilize but can non be accessed across database systems. It may be excess if alone identifier already exists.

Object containment

Each constituent in a design may incorporate other constituents and this can be modeled as containment of objects. Objects incorporating other objects are called composite objects. As for illustration consider the undermentioned figure:

Bicycle

Frame

Gear

Brake

Wheel

Cable

Pad

Lever

Spoke

Sur

Rim

Figure 14.4: Object Containment

Multiple degrees of containment create a containment hierarchy. In such instances, links are interpreted as is-part-of alternatively of is-a. Object containment allows informations to be viewed at different coarsenesss by different users.

We all know that object oriented linguistic communications provide the ability to mention to objects. An property of a type can be a mention to an object of a specified type. As for illustration, we can specify a type Course with a field courseID and a field nexus which is a mention to the type Student, and a table class of type Course, as follows:

create type Course (

courseID varchar ( 10 ) ,

nexus ref ( Student ) range pupil

)

create table class of Course

Here, the mention is restricted to tuples of the table pupil. For initialising a mention property, the identifier of the tuple that is to be referenced is required. So, to make a tuple with the mention value, we foremost create the tuple with a void mention and so put the mention individually:

insert into class

values ( ‘C001 ‘ , nothing )

update class

set nexus = ( choice ref ( s ) from pupil where SName=”Ravi ” )

where courseID = ‘C001 ‘

Referenced tabular array must hold an property that shops the identifier, called the self-referential property:

create table pupil of Student

ref is EnrollmentID system generated ;

Specifying a Schema

Specifying a scheme for an Object Oriented database means specifying object categories. We define here simple object categories for a company database described below:

CREATE CLASS Employee

Superclass: object

ATTRIBUTE employeeName: Fictional character,

ATTRIBUTE employeeAddress: Fictional character,

ATTRIBUTE dateOfBirth: Date,

ATTRIBUTE dateOfJoining: Date

CREATE CLASS Engineer

Superclass: Employee

RELATIONSHIP Department worksOn INVERSE departmentRegisters

RELATIONSHIP SET ( Domain ) belongsToDomain INVERSE domainSkill

CREATE CLASS Secretary

Superclass: Employee

RELATIONSHIP Department worksOn INVERSE departmentRegisters

CREATE CLASS Project

ATTRIBUTE EmployeeDetails: Employee,

ATTRIBUTE domainDetails: Sphere

We may explicate the scheme definition as follows:

Each category is defined by a alone name in the scheme: Employee, Engineer, Secretary and Project.

Three categories are defined on ace categories. The Employee category is said to organize a subclass of a system category ( meta-class ) called object.

The properties of the category Employee have been defined on pre-established informations types whole number, character and day of the month. These are said to be simple properties since they take a actual value and are defined on a standard information type such as whole number.

The subclasses Engineer and Secretary contain no property declarations, but contain relationship declarations for worksOn. For case, the Engineer category is declared as being related to the Department category. It is implicitly defined as a one-to-many nexus from Engineer to Domain since the relationship is implemented as a set of Domain identifiers. Both relationships have opposites defined. The opposite indicates a name for the traverse of the relationship from the linked category. Hence, the opposite relationship from Domain to Engineer is defined as domainSkill. This traverse will be defined in the Domain category and is besides likely to be one-to-many.

The category Undertaking might be considered one in which the construct of collection was of import. We might specify a Undertaking as being made up of Employee and Domain inside informations. The two properties in this category are complex properties since they contain aggregations and/or mentions – values that refer to other objects. Here the properties are defined as mentions to specific cases of other categories.

Persistent Programming Languages

Persistent scheduling linguistic communications ( PPL ) are those programming linguistic communications that allow objects to be even after the plan has been closed down. PPL by and large deals with relentless informations. A coder can pull strings relentless informations straight and there is no demand to bring it into memory and shop it back to disc, unlike embedded SQL. There is no demand for expressed format ( type ) alterations. Format alterations are carried out transparently by system. Without a relentless scheduling linguistic communication, format alterations become a load on the coder since more codification is to be written and there are more opportunities of bugs.

However the relentless scheduling linguistic communications suffer from certain drawbacks. Due to power of most programming linguistic communications, it is easy to do programming mistakes that damage the database. Besides, the Complexity of linguistic communications makes automatic high-ranking optimisation more hard and PPL do non back up declaratory querying every bit good as relational databases.

Continuity of objects

Persistent objects differ from transeunt objects in the sense that relentless objects is for lasting storage, whereas transient is for memory. Transient and relentless objects can entree each other reciprocally. Accessing a relentless object leads to lading the object into the transient pile. It is non accessed from transeunt objects any more, it will be written back to the relentless pile. A transeunt object becomes relentless every bit shortly as it can be reached from a relentless root. Approachs to do transeunt objects relentless include:

Continuity by category – This is to declare all objects of a category to be relentless. This attack is simple but inflexible.

Continuity by creative activity – To widen the sentence structure for making objects to stipulate that that an object is relentless.

Continuity by Taging – An object that is to prevail beyond plan executing is marked as relentless before plan expiration.

Continuity by reachability – To declare ( root ) persistent objects ; objects are relentless if they are referred to ( straight or indirectly ) from a root object. It is easier for coder, but more operating expense for database system and similar to garbage aggregation.

Object-Oriented versus Object-Relational Databases

We now have arrived to the last subject of this chapter. Here we will discourse how object oriented databases differ from object relational databases. We tabulate here the distinguishing characteristics:

Standards

Object Relational Database

Object Oriented Database

Use of datatypes

Object-relational databases are object-oriented databases built above the relational theoretical account and uses complex datatypes, but purpose at doing informations mold and questioning easier.

Persistent programming language-based OODBs uses really complex datatypes, with no informations interlingual rendition required. Can manage arbitrary complexness ; users can compose methods and on any construction.

Questioning capableness

Object relational databases have powerful querying capableness.

Questioning capableness of Object orientated database is hapless.

Security

Object relational databases provide high degree of security.

Security is compromised in Object oriented Database.

Simplicity of development

Provides independency of informations from application, good for simple relationships.

Objects are a natural manner to pattern ; can suit a broad assortment of types and relationships.

Extensibility and content

Limited largely to new informations types.

Can manage arbitrary complexness ; users can compose methods and on any construction.

Performance versus

interoperability

Degree of safety varies with seller, must be traded off ; accomplishing both requires extended testing.

Degree of safety varies with seller ; most ODBMSs allow coders to widen DBMS functionality by specifying new categories.

Bequest people and the

catholicity of SQL

Can take advantages of

RDBMS tools and developers.

SQL accommodated, but intended for object oriented coders.

The keyword “ opposite ” is used in which of the followers?

Class

Property

Relationship

All of the above

Which of the undermentioned is true refering an ODBMS?

They have the ability to hive away complex informations types on the Web.

They are catching RDBMS for all applications.

They are most utile for traditional, planar database tabular array applications.

All of the above.

Which of the followers is an disordered aggregation of elements that may incorporate extras?

Set

Bag

List

Dictionary

Which of the undermentioned is true refering the undermentioned statement: category Manager extends Employee

Manager is a concrete category and a superclass.

Manager is a concrete category and a subclass.

Manager is an abstract category and a superclass.

Manager is an abstract category and a subclass.

In object-oriented databases, what is the name given to the ability of objects to be after an application plan has terminated:

Inactive Binding

Continuity

Two stage commit

Object unity

What is the indispensable difference between object-oriented and conventional systems?

OO is more reclaimable

OO uses heritage

OO systems cut down development costs

Changes to informations constructions are localized

SUBJECTIVE TYPE QUESTIONS

Justify including properties in category descriptions.

Define object individuality.

What is multiple heritage? When should it be used?

How can inheritance be implemented in a relational database?

Why can the public presentation of a pure object-oriented database transcend a relational or object-relational one?

Define ‘object ‘ ( one sentence ) . Name the four constituents of an object.