This paper is an attack for migrating the relational databases to the object-relational databases. This attack is more advanced than other attacks because it provides algorithms with the transition of a RDB to an ORDB with the gaining control of collection, association and heritage.
Abstraction
This document trades with the transition of RDB to ORDB seen the benefits that offers the ORDB, the passage is done with methods that can pull out the assorted maps from a RDB which is based on collections, associations between the assorted tabular arraies and the automatic relationships. These methods can pull out even the heritage cognizing that no procedure of contrary technology can non cognize that it is an Inheritance, so my attack exceeded all of the surveies already made for aˆ‹aˆ‹the passage from RDB to ORDB. To sum up in three stairss, the creative activity of NDM that stocks the RDB in a signifier of a structured tabular array, from the NDM we create our navigational theoretical account to simplify the execution object from which we develop our different types, through these types we proceed for the last measure, the creative activity of tabular arraies.
The measure mentioned supra does non necessitate any human intervention. All this is done in an automatic manner, and a paradigm has already been created which proves the effectivity of this attack.
Introduction
Many jobs have emerged with the DBR, I quote from them the Reconstruction of complex objects split across relational tabular arraies is dearly-won because it causes many articulations. For this a solution has appeared, it ‘s the BDOR who has addressed most of these jobs, I quote from them the usage of mention facilitates the usage of really big multimedia informations by leting them merely sharing and lesser cost.
But the inquiry that arises is how to accomplish a migration from RDB to an ORDB
Several attacks have addressed the subject of migration, among them the attack of Eric Pardede, J. Wenny Rahayu and David Taniar [ 1 ] , which shows the transmutation of the collection and associations from the conceptual theoretical account to the object relational based on the impression of aggregations of the UML. Other attack that is based on the creative activity of a ORDB from the UML [ 4 ] .
The attack of Maatuk Abdelsalam, M. Akhtar Ali, Nick Rossiter [ 2 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] , which takes all of the relational database and shop it in a structured tabular array that holds several parametric quantities, tabular arraies, properties, categorization, category type ( abstract / concrete ) , the name of the relationship, category that interacts with the relationship and cardinalities to recognize the schema Translation.
But all attacks require the intervention of the human factor in order to accomplish migration, on all the work, or on one or several parts.
That is why in this paper we propose a method that requires no human intervention.
While our attack is based on capturing metadata from a BDR, dainty and shop it as a structured tabular array that holds the information necessary for the migration.
This paper deals with the stairss of the migration that are composed of 3 parts, the first portion is the execution of the structured tabular array & A ; lt ; & A ; lt ; NDM & A ; gt ; & A ; gt ; in Section 2, the 2nd portion of the transition from the NDM to the navigational theoretical account [ 3 ] in Section 3, and the 3rd portion trades with the transmutation of MNav to DBOR.
New Data Model
definition
The NEW DATA MODEL is a kind of table describes the different categories extracted from a RDB with the informations necessary for the realisation of an ORDB.
Designation of the NDM
The NDM is defined as a aggregation of categories NDM: = { C | C: = ( cn, grade, chlorine, a, subscriber ) }
Cn =the name of the category.
Degree = foremost degree | 2nd grade.
Cls=aggregation, association, heritage, simple category.
contributor=class list.
A=attribute: = { a|a: = ( an, T, ticket, cubic decimeter, n, vitamin D ) }
An =name of the property
T=type of the property
Tag=key ( primary | secondary )
L= length of the property
N=if the property takes the parametric quantity nothing
D=the default value of the property
*observation: treating cardinalities ca n’t assist us since the transmutation of CDM ( conceptual informations theoretical account ) to the LDM ( logical informations theoretical account ) in RDB has already treated for the migration of properties.
Degree
-Each tabular array in the RDB has a grade.
-The grade consists of two parts:
+1st grade: the tabular arraies that contain PK.
+2nd grade: the tabular arraies that contain FK without PK.
Classification ( chlorine )
For categorization, categories are composed of four parts
The simple categories: these are the categories of the first grade and which are non within the categorization of collection, heritage and association.
Collection: is when the category interact with a individual category ( the category itself may be the ( first grade | 2nd grade ) ) , non included in the categorization and heritage as the category has a FK.
Associations: a category of 2nd grade which interacts with two or more categories.
Particular instance: for automatic relationships including their cardinalities in the CDM were « 1-n» «0-n » go an association with two FK with the name of the property of FK non found in any other tabular array in the RDB, which includes a particular intervention of the entities to cognize the referencing.
Inheritance: When a category inherits from another category ( no contrary attack can place the heritage )
For this we developed a technique that is based on making a tabular array that will incorporate a upper limit of possible chance of heritage in conformity with the naming criterions, so our tabular array will dwell of two columns, first column contains the female parent category and the 2nd column, the subclasses ;
And we compare the list of Pk from the NDM and look into if there is a lucifer between two or more keys. If there is a correspondence, we will compare the name of the first category grade to the first column of our created table.If we find a lucifer we will compare the categories involved in our category with the elements of the 2nd column in the same row of the tabular array.So if there is a lucifer we will pull out an Inheritance, if non we will go on our intervention of categorization knowing that the intervention of heritage is the first measure of the categorization.
illustration:
inherited by
inherits
Person
Student
instructor
Animal
Cat
Dog
Horse
Document
Book
newspaper
History
Savingss
Current
…
…
…
…
Table 1: this tabular array represents the instance of heritage the most common
subscriber
This is the list of categories that the category starts interacting with them.
The intent of this portion knows whether it is an collection, an association, a individual category or a category that inherits from the category starting, besides for the creative activity of mention during the passage to the ORDB
Coevals of the NDM from a RDB
The interlingual rendition of the RDB to the NDM is the first measure of the migration into the ORDB
Example
Sing the RDB include: F: CED ( or ) BDR_img – Copie.png
The PKs are in bold underline ex
The FKs are underline ex
The NDM generated from a BDR
Cn
Degr & A ; eacute ;
categorization
attribut
intervenant
An
type
ticket
cubic decimeter
Nitrogen
vitamin D
Person
1er
inherBy
Pno
Varchar
PK
Nitrogen
childs
Dept
Works_on
Trainee
Employment
Person
Pname
Varchar
Nitrogen
Bdate
Date
Nitrogen
Adress
Varchar
255
Nitrogen
Dno
Int
FK
Nitrogen
Dept
PnoSup
Varchar
FK
Yttrium
Person
Trainee
2eme
Inherts
Pno
Varchar
FK
Nitrogen
Person
Degree
Varchar
Nitrogen
Type
Varchar
Nitrogen
Employment
2eme
Inherts
Pno
Varchar
FK
Nitrogen
Person
Salary
Int
Yttrium
Class
Varchar
FK
Nitrogen
Works_on
2eme
association
Prno
Int
FK
Nitrogen
Proj
Pno
Varchar
FK
Nitrogen
Person
Dept
1er
simple
Dno
Int
PK
Nitrogen
Person
Dname
Varchar
Nitrogen
Proj
1er
simple
Prno
Int
PK
Nitrogen
Work_on
Prname
Varchar
Nitrogen
Description
Varchar
255
Yttrium
Childs
1er
collection
Kno
Int
PK
Nitrogen
Kname
Varchar
Nitrogen
Sexual activity
Char
Nitrogen
Pno
Varchar
FK
N
Person
Consequence of the coevals of the NDM.
Observation: VARCHAR is synonymous with VARCHAR2 but this use may alter in future versions ( provided for backward compatibility merely for Oracle datatypes ) .
MNAV ( model navigational )
After obtaining the CDM, we create the navigational theoretical account.
Definition
a theoretical account that schematizes the object execution of a database while pulling up the pilotage way between dealingss with the rule of citing.
Aims
_ easing the passage towards the object by a set of regulations for heterotaxy.
_ Promoting visual image of complex constructions and pilotage waies possible.
Why navigational?
_ the theoretical account introduces the logical links of the type REF ( REF execution is undetermined in the conceptual degree ) .
_the mentions ( ref or REF ) facilitate the pilotage between objects.
Our categories will be divided into two parts, the external categories and internal categories:
+ Internal categories are the categories classified as collection in the NDM.
+ External categories are the other categorizations in the NDM.
Examples:
Extern
Attr1
Attr2
Attr3
Attr4
Intern
Attr6
Attr7
Example MNAV from go throughing UML:
Occupation
noA
noma
0..1
emploie
0..n
Employment
noE
Nome
m & A ; eacute ; tier
UML
occupation
noA
noma
lesEmploye
Employment
noE
Nome
metierE
MNAV
Note: The association is made aˆ‹aˆ‹by an external nexus that uses a mention to one or many objects of the category employ.
Navigation symbol:
Simple
Multiple
Lien simple nexus
Single nexus can be void
individual nexus Necessarily valued
The absence of the circle means needfully valued
Multiple nexus
multiple nexus can be void
multiple link Necessarily valued
The absence of the circle means needfully valued
Transformation regulations
Inheritance:
It follows the same rule of the category diagram in UML, either for the parent category or subclass.
Association:
The pilotage nexus is simple and needfully valued maintaining properties if it ‘s an association with the category attributes.
The pilotage links indicating from the category association to the category that interacts with it ( cosmopolitan solution ) .
Class 1
Attr1
Attr2
Association
Ref1
Ref2
Class 2
Attr3
Attr4
There is another type of representation:
+ No penchant of class, two multiple links with two new properties of type Ref.
Class 1
Attr1
Attr2
Class 2
Attr3
Attr4
Danger of incoherency, the forget of update when canceling
+ Two links are multiple and two individual.
Class 1
Attr1
Attr2
Ref3
Association
Ref1
Ref2
Class 2
Attr3
Attr4
Ref4
Collection:
It becomes an internal category type object referenced by an property of assembly with a multiple nexus can be void.
Simple category:
For the simple category we must see the categorization of the category that interacts with it.
+ If it is an association we will non necessitate to follow the way of pilotage because it is already done.
+ when a simple category interacts with another simple category, we have two pilotage links, the first starts of the category that contains a foreign key which is a primary key in the other category, the nexus is simple and needfully valued.
The 2nd nexus starts from the other category, which is multiple and can be void.
NDM transformed into MNAV.
Person
Pno
Pname
Bdate
Adress
laDept
lesKids
Childs
Kno
Kname
Sexe
Works_on
lesPerson
lesProj
Proj
Prno
Prname
Description
Employment
Pno
Salary
Class
Trainee
Pno
Degree
Type
Dept
Dno
Dname
lesEmps
Translation of the NDM to ORDB
attack for the interlingual rendition of the NDM into ORDB
the creative activity of types
+ Creation of the types defined in the NDM as collection.
+ Creation of the types defined in the NDM as association.
For the creative activity of the types we keep the same name listed in the RDB and we add _type ( concatenation )
+ Creation of composite types ( categories come ining in coaction with the collection taking into account their categorization ) and other types which their categorization in the NDM is simple.
+ The creative activity of the types defined in the NDM as an heritage get downing with the parent category and stoping with the subclasses.
making tabular arraies
The creative activity of tabular arraies is made by the typed categories, named in the NDM as heritage ( parent, subclasses ) , association, simple category and collections, they are included in the category of first grade that interacts within, all tabular arraies are created with the necessary restraints.
method of making and appellative regulation
To make the types we keep the same name that appears in the RDB and we add _type ( concatenation )
Syntax
CREATE [ OR REPLACE ] TYPE nameBDR_Type AS OBJECT
( colonne1 type1, colonne2 type2, … )
To make types that contain other types that represent collections, the type name that represents the collection remains the same and we added _t
Syntax
CREATE [ OR REPLACE ] TYPE nameRDB1_Type AS OBJECT
( column1 type1, column2 type2, … )
/
CREATE [ OR REPLACE ] TYPE nameRDB2_Type AS OBJECT
( column1 type1, column2 type2, nameRDB1_t set ( nameRDB1_type ) , … )
For the creative activity of types with mentions, we add a ref_ following to the name of the RDB with the keyword REF and the referenced type.
Observation: for automatic relationships near many recordings [ 1-n ] we concatenate the PK with the FK, and the side of a individual record [ 1-1 ] we concatenate the FK with the PK.
Syntax
CREATE [ OR REPLACE ] TYPE nameRDB1_Type AS OBJECT
( column1 type1, column2 type2, … )
/
CREATE [ OR REPLACE ] TYPE nameRDB2_Type AS OBJECT
( column1 type1, column2 type2, nameRDB1_t nameRDB1_type, … )
/
CREATE [ OR REPLACE ] TYPE nameRDB3_Type AS OBJECT
( column1 type1, column2 type2, ref_nameRDB2 REF nameRDB2_type, … )
For the creative activity of types that represent the heritage, we add Under for the sub category and the keyword non concluding if the type has subtypes, and concluding if the type has no subtypes.
Syntax
CREATE [ OR REPLACE ] TYPE nameRDB1_Type AS OBJECT
( column1 type1, column2 type2, … )
NOT FINAL
/
CREATE [ OR REPLACE ] TYPE nameRDB2_Type under nameRDB_type
( column1 type1, column2 type2, nameRDB1_t nameRDB1_type, … )
Final
Making tabular arraies starts from typed categories, the table keeps the same name that appears in the RDB, we add the keyword OF and the type matching with the restraints captured in the NDM ( PK restraint, mention restraint, non void restraint… ) .
Syntax:
CREATE TABLE [ scheme. ] nameTable OF [ scheme. ] nameType
[ ( column [ DEFAULT look ] [ constraintOnLine [ constraintOnLine ] …| constraintREFOnLine ]
| { constraintOffline | constraintREFOffline }
[ , column… ] ) ];
concluding consequence of the migration
CREATE TYPE kids_type AS OBJECT
( kno int, kname varchar ( 20 ) , sex char ( 1 ) , pno varchar ( 20 ) )
/
CREATE TYPE dept_type AS OBJECT
( dno int, dname varchar ( 20 ) )
/
CREATE TYPE proj_type AS OBJECT
( prno int, prname varchar ( 20 ) , description varchar ( 255 ) )
/
CREATE TYPE person_type AS OBJECT
( pno varchar ( 10 ) , pname varchar ( 20 ) , bdate day of the month, reference varchar ( 255 ) , dno int, pnosup varchar ( 20 ) , kids_t set ( kids_type ) , ref_dept ref ( dept_type ) range dept, ref_pno_pnosup set ( ref ( person_type ) ) , ref_pnosup_pno ref ( person_type ) scope individual )
NOT FINAL
/
CREATE TYPE trainee_type UNDER person_type
( pno varchar ( 10 ) , flat varchar ( 20 ) , type varchar ( 20 ) )
Final
/
CREATE TYPE employe_type UNDER person_type
( pno varchar ( 10 ) , salary int, class varchar ( 20 ) )
Final
/
CREATE TYPE work_on_type AS OBJECT
( prno int, pno varchar ( 20 ) , ref_proj set ( ref ( proj_type ) ) , ref_person set ( ref ( person_type ) ) )
/
CREATE TABLE dept OF dept_type (
restraint pk_dept primary key ( dno ) ) ;
CREATE TABLE proj OF proj_type (
restraint pk_proj primary key ( prno ) ) ;
CREATE TABLE work_on OF work_on_type (
restraint refer_work_on_person ref_person mentions individual,
restraint refer_work_on_proj ref_proj mentions proj ) ;
CREATE TABLE individual OF person_type (
restraint pk_person primary key ( pno ) ,
restraint refer_person ref_dept mentions dept ) ;
CREATE TABLE trainee OF trainee_type UNDER individual ;
CREATE TABLE employe OF employe_type UNDER individual ;
Decision
The current work shows us the stairss of traveling from a RDB to ORDB with a simple and practical method to capture the relationships between different categories, associations, collections and even the heritage that no attack has proposed a solution to pull out it from a RDB. So we can follow the navigational theoretical account to better see how the pilotage is made between categories and esteem the pilotage links for best listings.
So this solution exceeds the bing plants as it generates an ORDB without the intervention of the human factor, a paradigm was created to turn out the effectivity of this attack.
