Describe/discuss both a major similarity and then a major difference between an
ID: 3695698 • Letter: D
Question
Describe/discuss both a major similarity and then a major difference between an object oriented database and a relational database? Additionally, address how one can reconcile the differences between currently popular object oriented (OO) developments (GUI and processing layers) in concert with also popular relational databases to persistently hold and flexibly manipulate the data for the application (i.e. the object-relational mismatch [so-called impedance mismatch] between objects and the normalized table structure of a relational database
Explanation / Answer
Relational Databases
The Relational database model is:
Made up of tables
Relational databases support
If it doesn't fit any of the above, then it is a
Why Object-oriented Databases?
Because object-oriented databases are good at handling BLOBs, and the new world of information is all about BLOBs.
BLOBs like:
Relational vs Object-Oriented
RDs:
OODs:
A relational databases relies on the relational model, on the other hand a object database relies on the OOP.
The relational model organizes information in a set of tables each are composed of rows and columns. Each column represents a property and each row represent an entity.
In a object oriented database each element resembles a object from the object oriented paradigm.
It is reasonable easy to map object into relational databases. For more information about the topic check these links: link1, link2.
The object-relational impedance mismatch is a set of conceptual and technical difficulties that are often encountered when a relational database management system(RDBMS) is being used by a program written in an object-oriented programming language or style, particularly when objects or class definitions are mapped in a straightforward way to database tables or relational schemata.
The term object-relational impedance mismatch is derived from the electrical engineering term impedance matching.
Object-oriented concepts:
Encapsulation:
Object-oriented programs are designed with techniques that result in encapsulated objects whose representation is hidden. In an object-oriented framework, the underlying properties of a given object are expected to be unexposed to any interface outside of the one implemented alongside the object. However, object-relational mapping necessarily exposes the underlying content of an object to interaction with an interface that the object implementation cannot specify. Hence, object-relational mapping violates the encapsulation of the object.
Accessibility:
In relational thinking, "private" versus "public" access is relative to need rather than being an absolute characteristic of the data's state, as in the object-oriented (OO) model. The relational and OO models often have conflicts over relativity versus absolutism of classifications and characteristics.
Interface, class, inheritance and polymorphism:
Under an object-oriented paradigm, objects have interfaces that together provide the only access to the internals of that object. The relational model, on the other hand, utilizes derived relation variables (views) to provide varying perspectives and constraints to ensure integrity. Similarly, essential OOP concepts for classes of objects, inheritance andpolymorphism, are not supported by relational database systems.
Mapping to relational concepts:
A proper mapping between relational concepts and object-oriented concepts can be made if relational database tables are linked[further explanation needed] to associations found inobject-oriented analysis.
Data type differences:
A major mismatch between existing relational and OO languages is the type system differences. The relational model strictly prohibits by-reference attributes (or pointers), whereas OO languages embrace and expect by-reference behavior. Scalar types and their operator semantics can be vastly different between the models, causing problems in mapping.
For example, most SQL systems support string types with varying collations and constrained maximum lengths (open-ended text types tend to hinder performance), while most OO languages consider collation only as an argument to sort routines and strings are intrinsically sized to available memory. A more subtle, but related example is that SQL systems often ignore trailing white space in a string for the purposes of comparison, whereas OO string libraries do not. It is typically not possible to construct new data types as a matter of constraining the possible values of other primitive types in an OO language.
Solving impedance mismatch:
Solving the impedance mismatch problem for object-oriented programs starts with recognition of the differences in the specific logic systems being employed, then either the minimization or compensation of the mismatch.
Minimization:
There have been some attempts at building object-oriented database management systems (OODBMS) that would avoid the impedance mismatch problem. They have been less successful in practice than relational databases however, partly due to the limitations of OO principles as a basis for a data model.[1] There has been research performed in extending the database-like capabilities of OO languages through such notions as transactional memory.
One common solution to the impedance mismatch problem is to layer the domain and framework logic. In this scheme, the OO language is used to model certain relational aspects at runtime rather than attempt the more static mapping. Frameworks which employ this method will typically have an analogue for a tuple, usually as a "row" in a "dataset" component or as a generic "entity instance" class, as well as an analogue for a relation. Advantages of this approach may include:
Disadvantages may include: