Object-relationele database - Object–relational database

Een object-relationele database ( ORD ), of object-relationeel databasebeheersysteem ( ORDBMS ), is een databasebeheersysteem (DBMS) vergelijkbaar met een relationele database , maar met een objectgeoriënteerd databasemodel : objecten, klassen en overerving zijn rechtstreeks ondersteund in databaseschema's en in de querytaal . Bovendien ondersteunt het, net als bij pure relationele systemen, uitbreiding van het datamodel met aangepaste datatypen en methoden .

Image
Voorbeeld van een objectgeoriënteerd databasemodel

Een object-relationele database biedt een middenweg tussen relationele databases en objectgeoriënteerde databases . In object-relationele databases is de benadering in wezen die van relationele databases: de gegevens bevinden zich in de database en worden gezamenlijk gemanipuleerd met queries in een querytaal; aan het andere uiterste zijn OODBMS'en waarin de database in wezen een persistente objectopslag is voor software die is geschreven in een objectgeoriënteerde programmeertaal , met een programmeer- API voor het opslaan en ophalen van objecten, en weinig of geen specifieke ondersteuning voor query's.

Overzicht

De basisbehoefte van een object-relationele database komt voort uit het feit dat zowel relationele als objectdatabases hun individuele voor- en nadelen hebben. Het isomorfisme van het relationele databasesysteem met een wiskundige relatie stelt het in staat om veel bruikbare technieken en stellingen uit de verzamelingenleer te benutten. Maar dit soort databases zijn niet optimaal voor bepaalde soorten toepassingen. Een objectgeoriënteerd databasemodel staat containers zoals sets en lijsten, willekeurige door de gebruiker gedefinieerde datatypes en geneste objecten toe. Dit brengt overeenkomsten tussen de systemen van het applicatietype en het databasetype, waardoor elk probleem van impedantie-mismatch wordt weggenomen. Maar objectdatabases bieden, in tegenstelling tot relationele databases, geen wiskundige basis voor hun diepgaande analyse.

Het basisdoel van de object-relationele database is het overbruggen van de kloof tussen relationele databases en de objectgeoriënteerde modelleertechnieken die worden gebruikt in programmeertalen zoals Java , C ++ , Visual Basic .NET of C # . Een populairder alternatief voor het bereiken van een dergelijke brug is echter het gebruik van een standaard relationeel databasesysteem met een of andere vorm van object-relationele mapping (ORM) -software. Terwijl traditionele RDBMS- of SQL-DBMS-producten zich richten op het efficiënt beheer van gegevens die zijn ontleend aan een beperkte set datatypes (gedefinieerd door de relevante taalstandaarden), stelt een object-relationeel DBMS softwareontwikkelaars in staat om hun eigen typen en de methoden die gelden voor hen in het DBMS.

De ORDBMS (zoals ODBMS of OODBMS ) is geïntegreerd met een objectgeoriënteerde programmeertaal . De karakteristieke eigenschappen van ORDBMS zijn 1) complexe gegevens, 2) type-overerving en 3) objectgedrag. Complexe gegevenscreatie in de meeste SQL ORDBMS'en is gebaseerd op een voorlopige schemadefinitie via het door de gebruiker gedefinieerde type (UDT). Hiërarchie binnen gestructureerde complexe gegevens biedt een extra eigenschap, type overerving . Dat wil zeggen, een gestructureerd type kan subtypen hebben die al zijn attributen hergebruiken en aanvullende attributen bevatten die specifiek zijn voor het subtype. Een ander voordeel, het objectgedrag , houdt verband met de toegang tot de programma-objecten. Dergelijke programmaobjecten moeten kunnen worden opgeslagen en vervoerd voor databaseverwerking, daarom worden ze gewoonlijk aangeduid als persistente objecten . Binnen een database zijn alle relaties met een persistent programma-object relaties met zijn object-ID (OID) . Al deze punten kunnen worden aangepakt in een goed relationeel systeem, hoewel de SQL-standaard en zijn implementaties willekeurige beperkingen en extra complexiteit opleggen

Bij objectgeoriënteerd programmeren (OOP) wordt objectgedrag beschreven via de methoden (objectfuncties). De methoden die met één naam worden aangeduid, onderscheiden zich door het type van hun parameters en het type objecten waaraan ze zijn gekoppeld ( methodehandtekening ). De OOP-talen noemen dit het polymorfisme- principe, dat in het kort wordt gedefinieerd als "één interface, veel implementaties". Andere OOP-principes, overerving en inkapseling , houden verband met zowel methoden als attributen. Methode-overerving is inbegrepen in type-overerving. Inkapseling in OOP is een zichtbaarheidsgraad die bijvoorbeeld wordt gedeclareerd via de public , private en protected toegangsmodificatoren .

Geschiedenis

Object-relationele databasebeheersystemen zijn ontstaan ​​uit onderzoek dat begin jaren negentig plaatsvond. Dat onderzoek breidde bestaande relationele databaseconcepten uit door objectconcepten toe te voegen . De onderzoekers wilden een declaratieve zoektaal op basis van predikatenrekening als centraal onderdeel van de architectuur behouden. Waarschijnlijk het meest opmerkelijke onderzoeksproject, Postgres (UC Berkeley), bracht twee producten voort die hun afstamming naar dat onderzoek herleiden: Illustra en PostgreSQL .

Halverwege de jaren negentig verschenen vroege commerciële producten. Deze omvatten Illustra (Illustra Information Systems, overgenomen door Informix Software , die op zijn beurt overgenomen door IBM ), Alwetendheid (Alwetendheid Corporation, overgenomen door Oracle Corporation en werd de oorspronkelijke Oracle Lite) en UniSQL (UniSQL, Inc., overgenomen door KCOMS ). De Oekraïense ontwikkelaar Ruslan Zasukhin, oprichter van Paradigma Software, Inc. , ontwikkelde en verscheepte halverwege de jaren negentig de eerste versie van de Valentina-database als een C ++ SDK . In het volgende decennium was PostgreSQL een commercieel levensvatbare database geworden en vormt het de basis voor verschillende huidige producten die de ORDBMS-functies behouden.

Computerwetenschappers noemden deze producten "object-relationele databasebeheersystemen" of ORDBMS'en.

Veel van de ideeën van vroege object-relationele database-inspanningen zijn grotendeels via gestructureerde typen in SQL: 1999 verwerkt . In feite zou elk product dat voldoet aan de objectgeoriënteerde aspecten van SQL: 1999 kunnen worden omschreven als een object-relationeel databasebeheerproduct. De DB2 , Oracle-database en Microsoft SQL Server van IBM beweren bijvoorbeeld deze technologie te ondersteunen en doen dit met wisselend succes.

Vergelijking met RDBMS

Een RDBMS kan gewoonlijk SQL- instructies bevatten zoals deze: 

   CREATE TABLE Customers  (
       Id          CHAR(12)    NOT NULL PRIMARY KEY,
       Surname     VARCHAR(32) NOT NULL,
       FirstName   VARCHAR(32) NOT NULL,
       DOB         DATE        NOT NULL   # DOB: Date of Birth
    );
    SELECT InitCap(Surname) || ', ' || InitCap(FirstName)
      FROM Customers
     WHERE Month(DOB) = Month(getdate())
       AND Day(DOB) = Day(getdate())

Met de meeste huidige SQL-databases kunnen aangepaste functies worden gemaakt , waardoor de query kan worden weergegeven als: 

    SELECT Formal(Id)
      FROM Customers
     WHERE Birthday(DOB) = Today()

In een object-relationele database zou je zoiets als dit kunnen zien, met door de gebruiker gedefinieerde gegevenstypen en uitdrukkingen zoals BirthDay() : 

    CREATE TABLE Customers (
      Id           Cust_Id     NOT NULL  PRIMARY KEY,
      Name         PersonName  NOT NULL,
      DOB          DATE        NOT NULL
    );
    SELECT Formal( C.Id )
      FROM Customers C
     WHERE BirthDay ( C.DOB ) = TODAY;

Het object-relationele model kan een ander voordeel bieden doordat de database gebruik kan maken van de relaties tussen gegevens om eenvoudig gerelateerde records te verzamelen. In een adresboektoepassing zou een extra tabel aan de bovenstaande worden toegevoegd om nul of meer adressen voor elke klant te bevatten. Met behulp van een traditioneel RDBMS is voor het verzamelen van informatie voor zowel de gebruiker als zijn adres een "join" vereist: 

     SELECT InitCap(C.Surname) || ', ' || InitCap(C.FirstName), A.city
       FROM Customers C join Addresses A ON A.Cust_Id=C.Id -- the join
      WHERE A.city="New York"

Dezelfde zoekopdracht in een object-relationele database wordt eenvoudiger weergegeven: 

    SELECT Formal( C.Name )
      FROM Customers C
     WHERE C.address.city="New York" -- the linkage is 'understood' by the ORDB

Zie ook

Referenties

Externe links