StudyMoose App
24/7 writing help on your phone
Save to my list
Remove from my list
Thankss to the Internet, the legal demand to maintain path of tonss of concern information, new selling methods, and the detonation of data-intensive scientific advancement, databases are being used more than of all time before for storing and accessing information. There are presently three different theoretical accounts in usage for database direction systems: relational, object-oriented, and object-relational. This article introduces all three, and discusses their comparative strengths and failings.
Edgar F. Codd at IBM invented the relational database in 1970.
Referred to as RDBMS, the relational theoretical account extended two old database systems, the hierarchal and the web theoretical accounts. After Codd 's development, `` paradigm RDBMS were developed at IBM and UC-Berkeley, and several sellers were offering relational database merchandises shortly thenceforth. ''
The relational theoretical account is based on the construction of a database. A database is merely a aggregation of one or more dealingss or tabular arraies with columns and rows.
5 (339)
“ KarrieWrites did such a phenomenal job on this assignment! He completed it prior to its deadline and was thorough and informative. ”
The usage of set theory allows for informations to be structured in a series of tabular arraies that has both columns and rows. Each column corresponds to an property of that relation, while each row corresponds to a record that contains informations values for an entity.
The chief elements of RDBMS are based on Ted Codd 's 13 regulations for aA relational system, the construct of relational unity, and standardization. The three basicss of a relational database are that all information must be held in the signifier of a tabular array, where all informations are described utilizing informations values.
The 2nd fundamental is that each value found in the table columns does non reiterate. The concluding fundamental is the usage of Standard Query Language ( SQL ) .
Benefits of RDBMS are that the system is simple, flexible, and productive. BecauseA the tabular arraies are simple, informations is easier to understand and pass on with others. RDBMS are flexible because users do non hold to utilize predefined keys to input information. Besides, A RDBMS are more productive because SQL is easier to larn. This allows users to pass more timeA inputting alternatively of larning. More significantly, RDBMS 's biggestA advantage is the easiness with which users canA create and entree informations and widen it if needed. After the original database is created, new informations classs can be added without the bing application being changed.
There are restrictions to the relational database direction system. First, relational databases do non hold adequate storage country to manage informations such as images, digital and audio/video. The system was originally created to manage the integrating of media, traditional fielded information, and templets. Another restriction of the relational database is its insufficiency to run with linguistic communications outside of SQL. After its original development, linguistic communications such as C++ and JavaScript were formed. However, relational databases do non work expeditiously with these linguistic communications. A 3rd restriction is the demand that information must be in tabular arraies where relationships between entities are defined by values.
Today, the relational theoretical account is the dominant informations theoretical account every bit good as the foundation for the taking DBMS merchandises, which include IBM 's DB2 household, Informix, Oracle, Sybase, Microsoft 's Access and SQLServer, every bit good as FoxBase and Paradox. RDBMS represent near to a multibillion-dollar industry entirely.
2
To battle the restrictions of RDBMS and run into the challenge of the increasing rise of the Internet and the Web, coders developed object-oriented databases in the 1980s. The chief aim of Object-Oriented Database Management Systems, normally known as OODBMS, is to supply consistent, informations independent, secure, controlled and extensile information direction services to back up the object-oriented theoretical account. They were created toA grip large and complex informations that relational databases could non.
There are of import features involved with object-oriented databases. The most of import feature is the connection of object-oriented scheduling with database engineering, which provides an incorporate application development system. Object-oriented scheduling consequences in 4 chief features: A heritages, informations encapsulation, object individuality, and polymorphism. Inheritance allows one to develop solutions to complex jobs incrementally by specifying new objects in footings of antecedently defined objects.
Data encapsulation or merely encapsulation allows the concealment of the internal province of the objects. Encapsulated objects are those objects that can merely be assessed by their methods alternatively of their internal provinces. There are three types of encapsulated objects users and developers should acknowledge. The first is full encapsulation, in which all the operations on objects are done through message sending and method executing. The 2nd is write encapsulation, which is where the internal province of the object is seeable merely for reading operations. The 3rd is partial encapsulation, which involves leting direct entree for reading and composing for merely a portion of the internal province.
Object individuality allows objects of the database to be independent of each other. Polymorphism and dynamic binding let one to specify operations for one object and so to portion the specification of the operation with other objects. This allows users and/or coders to compose objects to supply solutions without holding to compose codification that is specific to each object.
The linguistic communication of import to OODBMS is data definition and use linguistic communication ( DDML ) . The usage of this linguistic communication allows relentless informations to be created, updated, deleted, or retrieved. An OODBMS needs a computational versus a relational linguistic communication because it can be used to avoid electric resistance mismatch. DDML allows users to specify a database, including making, changing, and dropping tabular arraies and set uping restraints. DDMLs are used to keep and question a database, including updating, inserting, modifying, and questioning informations.
The OODBMS has many advantages and benefits. First, object-oriented is a more natural manner of thought. Second, the defined operations of these types of systems are non dependent on the peculiar database application running at a given minute. Third, the informations types of object-oriented databases can be extended to back up complex informations such as images, digital and audio/video, along with other multi-media operations. Different benefits of OODBMS are its reusability, stableness, and dependability. Another benefit of OODBMS is that relationships are represented explicitly, frequently back uping both navigational and associatory entree to information. This translates to betterment in informations entree public presentation versus the relational theoretical account.
Another of import benefit is that users are allowed to specify their ain methods of entree to informations and how it will be represented or manipulated. The most important benefit of the OODBMS is that these databases have extended into countries non known by the RDBMS. Medicine, multimedia, and high-energy natural philosophies are merely a few of the new industries trusting on object-oriented databases.
As with the relational database method, object-oriented databases besides has disadvantages or restrictions. One disadvantage of OODBMS is that it lacks a common information theoretical account. There is besides no current criterion, since it is still considered to be in the development phases.
3
Object-oriented database engineering is a matrimony of object-oriented scheduling and database engineerings. Figure 1 illustrates how these scheduling and database constructs have come together to supply what we now call object-oriented databases.
Introduction to RDBMS OODBMS and ORDBMS
Possibly the most important characteristic of object-oriented database engineering is that it combines object-oriented scheduling with database engineering to supply an incorporate application development system. There are many advantages to including the definition of operations with the definition of informations. First, the defined operations apply ubiquitously and are non dependent on the peculiar database application running at the minute. Second, the informations types can be extended to back up complex informations such as multi-media by specifying new object categories that have operations to back up the new sorts of information.
Other strengths of object-oriented mold are good known. For illustration, heritage allows one to develop solutions to complex jobs incrementally by specifying new objects in footings of antecedently defined objects. Polymorphism and dynamic binding let one to specify operations for one object and so to portion the specification of the operation with other objects. These objects can farther widen this operation to supply behaviours that are alone to those objects. Dynamic adhering determines at runtime which of these operations is really executed, depending on the category of the object requested to execute the operation. Polymorphism and dynamic binding are powerful object-oriented characteristics that allow one to compose objects to supply solutions without holding to compose codification that is specific to each object. All of these capablenesss come together synergistically to supply important productiveness advantages to database application developers.
A important difference between object-oriented databases and relational databases is that object-oriented databases represent relationships explicitly, back uping both navigational and associatory entree to information. As the complexness of interrelatednesss between information within the database additions, so do theA advantages of stand foring relationships explicitly. Another benefit of utilizing expressed relationships is the betterment in informations entree public presentation over relational value-based relationships.
A alone feature of objects is that they have an individuality that is independent of the province of the object. For illustration, if one has a auto object and we remodel the auto and alteration its visual aspect, the engine, the transmittal, and the tyres so that it looks wholly different, it would still be recognized as the same object we had originally. Within an object-oriented database, one can ever inquire the inquiry, `` is this the same object I had antecedently? `` , presuming one remembers the object 's individuality. Object-identity allows objects to be related every bit good as shared within a distributed computer science web.
All of these advantages point to the application of object-oriented databases to information direction jobs that are characterized by the demand to pull off:
a big figure of different informations types,
a big figure of relationships between the objects, and
objects with complex behaviours.
Application countries where this sort of complexness exists includes technology, fabrication, simulations, office mechanization and big information systems.
4
Object-Relational database ( ORDBMS ) is the 3rd type of database common today. ORDBMS are systems that `` try to widen relational database systems with the functionality necessary to back up a broader category of applications and, in many ways, supply a span between the relational and object-oriented paradigms. ''
ORDBMS was created to manage new types of informations such as sound, picture, and image files that relational databases were non equipped to manage. In add-on, its development was the consequence of increased use of object-oriented scheduling linguistic communications, and a big mismatch between these and the DBMS package.
One advantage of ORDBMS is that it allows organisations to go on utilizing their bing systems, without holding to do major alterations. A 2nd advantage is that it allows users and coders to get down utilizing object-oriented systems in analogue.
There are challenges in implementing an ORDBMS. The first is storage and entree methods. The 2nd is query processing, and the 3rd is query optimisation.
Since the development of RDBMS, OODBMS, and ORDBMS, many sellers have extended their systems with the ability to hive away new informations types such as images and texts, and with the ability to inquire more complex questions.
One rise technique is enterprise resource planning and direction resource planning, which add another bed of application-oriented characteristics on top of a DBMS. Included applications come fromA Baan, Oracle, SAP, and Siebel. These plans each identify a set of common undertakings encountered by a big figure of organisations and supply a general application bed to transport out these undertakings.
More significantly, DBMS have advanced into the Internet and Web Age.A Stored information is widely being accessed through a Web browser. Today, questions are being generated through Web-accessible signifiers and replies are being formatted utilizing a mark-up linguistic communication such as HTML. In add-on, many sellers and distributers are adding characteristics to their DBMS aimed at doing it better equipped for Internet use.
In drumhead, relational and object-oriented database systems each have certain strengths every bit good as certain failings. In general, the failing of one type of system tends to be strength of the other.
5
In today 's universe, Client-Server applications that rely on a database on the waiter as a information shop while serving petitions from multiple clients are rather commonplace. Most of these applications use a Relational Database Management System ( RDBMS ) as their informations shop while utilizing an object oriented programming linguistic communication for development. This causes a certain inefficency as objects must be mapped to tuples in the database and frailty versa alternatively of the informations being stored in a manner that is consistent with the programming theoretical account. The `` electric resistance mismatch '' caused by holding to map objects to tabular arraies and frailty versa has long been accepted as a necessary public presentation punishment. This paper is aimed at seeking out an option that avoids this punishment.
What follows is a condensed version of the undermentioned paper ; An Exploration of Object Oriented Database Management Systems, which I wrote as portion of my independent survey undertaking under Dr. Sham Navathe.
The intent of this paper is to supply replies to the undermentioned inquiries
What is an Object Oriented Database Management System ( OODBMS ) ?
Is an OODBMS a feasible option to an RDBMS?
What are the trade-offs and benefits of utilizing an OODBMS over an RDBMS?
What does code that interacts with an OODBMS expression like?
An OODBMS is the consequence of uniting object oriented programming rules with database direction rules. Object oriented programming constructs such as encapsulation, polymorphism and heritage are enforced every bit good as database direction constructs such as the ACID belongingss ( Atomicity, Consistency, Isolation and Durability ) which lead to system unity, support for an ad hoc question linguistic communication and secondary storage direction systems which allow for pull offing really big sums of informations. The Object Oriented Database Manifesto [ Atk 89 ] specifically lists the undermentioned characteristics as mandatary for a system to back up before it can be called an OODBMS ; Complex objects, Object individuality, Encapsulation, Types and Classes, Class or Type Hierarchies, Overriding, overloading and late binding, Computational completeness, Extensibility, Persistence, Secondary storage direction, Concurrency, Recovery and an Ad Hoc Query Facility.
& gt ; From the aforesaid description, an OODBMS should be able to hive away objects that are about identical from the sort of objects supported by the mark programming linguistic communication with every bit small restriction as possible. Persistent objects should belong to a category and can hold one or more atomic types or other objects as properties. The normal regulations of heritage should use with all their benefits including polymorphism, overridding inherited methods and dynamic binding. Each object has an object identifier ( OID ) which used as a manner of unambiguously placing a particuler object. OIDs are lasting, system generated and non based on any of the member informations within the object. OIDs make hive awaying mentions to other objects in the database simpler but may do referential intergrity jobs if an object is deleted while other objects still have mentions to its OID. An OODBMS is therefore a full graduated table object oriented development environment every bit good as a database direction system. Features that are common in the RDBMS universe such as minutess, the ability to manage big sums of informations, indexes, dead end sensing, backup and Restoration characteristics and informations recovery mechanisms besides exist in the OODBMS universe.
A primary characteristic of an OODBMS is that accessing objects in the database is done in a crystalline mode such that interaction with relentless objects is no different from interacting with in-memory objects. This is really different from utilizing an RDBMSs in that there is no demand to interact via a query sub-language like SQL nor is there a ground to utilize a Call Level Interface such as ODBC, ADO or JDBC. Database operations typically involve obtaining a database root from the the OODBMS which is normally a information construction like a graph, vector, hash tabular array, or set and tracking it to obtain objects to make, update or cancel from the database. When a client requests an object from the database, the object is transferred from the database into the application 's cache where it can be used either as a transient value that is disconnected from its representation in the database ( updates to the cached object do non impact the object in the database ) or it can be used as a mirror of the version in the database in that updates to the object are reflected in the database and alterations to object in the database require that the object is refetched from the OODBMS.
There are constructs in the relational database theoretical account that are similar to those in the object database theoretical account. A relation or tabular array in a relational database can be considered to be correspondent to a category in an object database. A tuple is similar to an case of a category but is different in that it has properties but no behaviours. A column in a tuple is similar to a category property except that a column can keep merely crude informations types while a category property can keep informations of any type. Finally categories have methods which are computationally complete ( intending that general intent control and computational constructions are provided [ McF 99 ] ) while relational databases typically do non hold computationally complete programming capablenesss although some stored process languages come near.
Below is a list of advantages and disadvantages of utilizing an OODBMS over an RDBMS with an object oriented programming linguistic communication.
Composite Objects and Relationships: Objects in an OODBMS can hive away an arbitrary figure of atomic types every bit good as other objects. It is therefore possible to hold a big category which holds many medium sized categories which themselves hold many smaller categories, ad infinitum. In a relational database this has to be done either by holding one immense tabular array with tonss of void Fieldss or via a figure of smaller, normalized tabular arraies which are linked via foreign keys. Having tonss of smaller tabular arraies is still a job since a articulation has to be performed every clip one wants to question informations based on the `` Has-a '' relationship between the entities. Besides an object is a better theoretical account of the existent universe entity than the relational tuples with respects to complex objects. The fact that an OODBMS is better suited to managing complex, interrelated informations than an RDBMS means that an OODBMS can surpass an RDBMS by 10 to a 1000 times depending on the complexness of the informations being handled.
Class Hierarchy: Datas in the existent universe is normally has hierarchal features. The of all time popular Employee illustration used in most RDBMS texts is easier to depict in an OODBMS than in an RDBMS. An Employee can be a Manager or non, this is normally done in an RDBMS by holding a type identifier field or making another tabular array which uses foreign keys to bespeak the relationship between Directors and Employees. In an OODBMS, the Employee category is merely a parent category of the Manager category.
Besieging the Need for a Query Language: A question linguistic communication is non necessary for accessing informations from an OODBMS unlike an RDBMS since interaction with the database is done by transparently accessing objects. It is still possible to utilize questions in an OODBMS nevertheless.
No Impedence Mismatch: In a typical application that uses an object oriented programming linguistic communication and an RDBMS, a signifcant sum of clip is normally exhausted function tabular arraies to objects and back. There are besides assorted jobs that can happen when the atomic types in the database do non map flawlessly to the atomic types in the scheduling linguistic communication and frailty versa. This `` electric resistance mismatch '' is wholly avoided when utilizing an OODBMS.
No Primary Keies: The user of an RDBMS has to worry about unambiguously placing tuples by their values and doing certain that no two tuples have the same primary key values to avoid mistake conditions. In an OODBMS, the alone designation of objects is done behind the scenes via OIDs and is wholly unseeable to the user. Therefore there is no restriction on the values that can be stored in an object.
One Data Model: A information theoretical account typically should pattern entities and their relationships, restraints and operations that change the provinces of the informations in the system. With an RDBMS it is non possible to pattern the dynamic operations or regulations that change the province of the informations in the system because this is beyond the range of the database. Thus applications that use RDBMS systems normally have an Entity Relationship diagram to pattern the inactive parts of the system and a seperate theoretical account for the operations and behaviours of entities in the application. With an OODBMS there is no gulf between the database theoretical account and the application theoretical account because the entities are merely other objects in the system. An full application can therefore be comprehensively modelled in one UML diagram.
Schema Changes: In an RDBMS modifying the database scheme either by making, updating or canceling tabular arraies is typically independent of the existent application. In an OODBMS based application modifying the scheme by making, updating or modifying a relentless category typically means that alterations have to be made to the other categories in the application that interact with cases of that category. This typically means that all scheme alterations in an OODBMS will affect a system broad recompile. Besides updating all the case objects within the database can take an drawn-out period of clip depending on the size of the database.
The undermentioned information was gleaned from the ODBMS Facts web site.
The Chicago Stock Exchange manages stock trades via a Versant ODBMS.
Radio Computing Services is the universe 's largest wireless package company. Its merchandise, Selector, automates the demands of the full wireless station -- from the music library, to the newsroom, to the gross revenues section. RCS uses the POET ODBMS because it enabled RCS to incorporate and form assorted elements, irrespective of informations types, in a individual plan environment.
The Objectivity/DB ODBMS is used as a information depository for system constituent naming, satellite mission planning informations, and orbital direction informations deployed by Motorola in The Iridium System.
The ObjectStore ODBMS is used in SouthWest Airline 's Home Gate to supply self-service to travellers through the Internet.
Ajou University Medical Center in South Korea uses InterSystems ' Cache ODBMS to back up all infirmary maps including mission-critical sections such as pathology, research lab, blood bank, pharmaceutics, and X ray.
The Large Hadron Collider at CERN in Switzerland uses an Objectivity DB. The database is presently being tested in the 100s of TBs at informations rates up to 35 MB/second.
As of November, 2000, the Stanford Linear Accelerator Center ( SLAC ) stored 169 TBs of production informations utilizing Objectivity/DB. The production informations is distributed across several hundred processing nodes and over 30 online waiters.
Below are Java codification samples for accessing a relational database and accessing an object database. Compare the size of the codification in both illustrations. The illustrations are for an instant messaging application.
Validating a user.
import COM.odi. * ;
import COM.odi.util.query. * ;
import COM.odi.util. * ;
import java.util. * ;
seek {
//start database session
Session session = Session.create ( void, void ) ;
session.join ( ) ;
//open database and get down dealing
Database dubnium = Database.open ( `` IMdatabase '' , ObjectStore.UPDATE ) ;
Transaction tr = Transaction.begin ( ObjectStore.READONLY ) ;
//get hashtable of user objects from DB
OSHashMap users = ( OSHashMap ) db.getRoot ( `` IMusers '' ) ;
//get watchword and username from user
Stringing username = getUserNameFromUser ( ) ;
Stringing passwd = getPasswordFromUser ( ) ;
//get user object from database and see if it exists and whether watchword is right
UserObject user = ( UserObject ) users.get ( username ) ;
if ( user == nothing )
System.out.println ( `` Non-existent user '' ) ;
else
if ( user.getPassword ( ) .equals ( passwd ) )
System.out.println ( `` Successful login '' ) ;
else
System.out.println ( `` Invalid Password '' ) ;
//end dealing, close database and retain terminate session
tr.commit ( ) ;
db.close ( ) ;
session.termnate ( ) ;
//exception handling would travel here...
import java.sql. * ;
import sun.jdbc.odbc.JdbcOdbcDriver ;
import java.util. * ;
seek {
//Launch case of database driver.
Class.forName ( `` COM.ibm.db2.jdbc.app.DB2Driver '' ) .newInstance ( ) ;
//create database connexion
Connection conn = DriverManager.getConnection ( `` jdbc: db2: IMdatabase '' ) ;
//get watchword and username from user
Stringing username = getUserNameFromUser ( ) ;
Stringing passwd = getPasswordFromUser ( ) ;
//perform SQL question
Statement sqlQry = conn.createStatement ( ) ;
ResultSet rset = sqlQry.executeQuery ( `` SELECT watchword from user_table WHERE username= ' '' + username + '' ' '' ) ;
if ( rset.next ( ) ) {
if ( rset.getString ( 1 ) .equals ( passwd ) )
System.out.println ( `` Successful login '' ) ;
else
System.out.println ( `` Invalid Password '' ) ;
} else {
System.out.println ( `` Non-existent user '' ) ;
//close database connexion
sqlQry.close ( ) ;
conn.close ( ) ;
//exception handling would travel here...
There is n't much difference in the above illustrations although it does look a batch clearer to execute operations on a UserObject alternatively of a ResultSet when formalizing the user.
Geting the user 's contact list.
import COM.odi. * ;
import COM.odi.util.query. * ;
import COM.odi.util. * ;
import java.util. * ;
seek {
/* start session and unfastened DB, same as in subdivision 1a */
//get hashmap of users from the DB
OSHashMap users = ( OSHashMap ) db.getRoot ( `` IMusers '' ) ;
//get user object from database
UserObject c4l = ( UserObject ) users.get ( `` Carnage4Life '' ) ;
UserObject [ ] contactList = c4l.getContactList ( ) ;
System.out.println ( `` This are the people on Carnage4Life 's contact list '' ) ;
for ( int i=0 ; i & lt ; contactList.length ; i++ )
System.out.println ( contactList [ I ] .toString ( ) ) ; //toString ( ) prints fullname, username, on-line position and web page Uniform resource locator
/* close session and close DB, same as in subdivision 1a */
} //exception managing codification
import java.sql. * ;
import sun.jdbc.odbc.JdbcOdbcDriver ;
import java.util. * ;
seek {
/* unfastened DB connexion, same as in subdivision 1b */
//perform SQL question
Statement sqlQry = conn.createStatement ( ) ;
ResultSet rset = sqlQry.executeQuery ( `` SELECT fname, lname, user_name, online_status, web page FROM contact_list, user_table '' + `` WHERE contact_list.owner_name='Carnage4Life ' and contact_list.buddy_name=user_table.user_name '' ) ;
System.out.println ( `` This are the people on Carnage4Life 's contact list '' ) ;
while ( rset.next ( ) )
System.out.println ( `` Full Name: '' + rset.getString ( 1 ) + `` `` + rset.getString ( 2 ) + `` User Name: '' + rset.getString ( 3 ) + `` OnlineStatus: '' + rset.getString ( 4 ) + `` HomePage Uniform resource locator: '' + rset.getString ( 5 ) ) ;
/* near DB connexion, same as in subdivision 1b*/
} //exception managing codification
The benefits of utilizing an OODBMS over an RDBMS in Java easy becomes obvious. See besides that if the information from the select needs to be returned to another method so all the information from the consequence set has to be mapped to another object ( UserObject ) .
Get all the users that are on-line.
import COM.odi. * ;
import COM.odi.util.query. * ;
import COM.odi.util. * ;
import java.util. * ;
seek {
/* same as above */
//use a OODBMS question to turn up all the users whose position is 'online '
Query Q = new Query ( UserObject.class, `` onlineStatus.equals ( '' online '' '' ) ;
Collection users = db.getRoot ( `` IMusers '' ) ;
Set onlineUsers = q.select ( users ) ;
Iterator iter = onlineUsers.iterator ( ) ;
// iterate over the consequences
while ( iter.hasNext ( ) )
UserObject user = ( UserObject ) iter.next ( ) ;
// direct each individual some proclamation
sendAnnouncement ( user ) ;
/* same as above */
} //exception handling goes here
import java.sql. * ;
import sun.jdbc.odbc.JdbcOdbcDriver ;
import java.util. * ;
seek {
/* same as above */
//perform SQL question
Statement sqlQry = conn.createStatement
ResultSet rset = sqlQry.executeQuery
( `` SELECT fname, lname, user_name, online_status,
web page FROM user_table WHERE
online_status='online ' '' ) ;
while ( rset.next ( ) ) {
UserObject user = new UserObject
( rset.getString ( 1 ) , rset.getString
( 2 ) , rset.getString ( 3 ) , rset.getString
( 4 ) , rset.getString ( 5 ) ) ;
sendAnnouncement ( user ) ;
/* same as above */
} //exception handling goes here
Object Store
O2
Gem
Mountainside
Ontos
DB/Explorer ODBMS
Ontos
Poet
Objectivity/DB
EyeDB
Ozone
Zope
FramerD
XL2
The additions from utilizing an OODBMS while developing an application utilizing an OO scheduling linguistic communication are many. The nest eggs in development clip by non holding to worry about separate informations theoretical accounts every bit good as the fact that there is less codification to compose due to the deficiency of electric resistance mismatch is really attractive. In my sentiment, there is small ground to pick an RDBMS over an OODBMS system for newapplication development unless there are legacy issues that have to be dealt with.
Introduction To RDBMS OODBMS And ORDBMS Computer Science Essay. (2020, Jun 02). Retrieved from https://studymoose.com/introduction-to-rdbms-oodbms-and-ordbms-computer-science-new-essay
👋 Hi! I’m your smart assistant Amy!
Don’t know where to start? Type your requirements and I’ll connect you to an academic expert within 3 minutes.
get help with your assignment
