1. Object Query Language (OQL) and Language Binding
The ODMG Standard for Object Databases
Object Query Language (OQL) and Language Binding
Advanced Database Technologies
School of Computing, Engineering and Information Sciences
Dr. Akhtar Ali

2. OQL – for querying the database
OQL is the the query language in ODMG standard.
OQL is a superset of the SQL (in select-from-where clauses).
It can be interactive as well as embedded in other programming languages.
It is a declarative language.
OQL can invoke operations written in programming languages (C++, Java, Smalltalk).
The operators in the language can be freely composed.
OQL includes operators for creating collections, arithmetic and logical operators, aggregation, sorting and grouping.

3. Retrieving Objects or select l from l in Lecturers
The query returns all Lecturer objects who live in Newcastle. The type of the query result is bag<Person>.
Whenever the scope of an OQL query is a collection (e.g. Lecturers, a set of Lecturer objects), we define an iterator variable that ranges over the collection (e.g. l in Lecturer). In the query l denotes an object of type Lecturer.
select l
from l in Lecturers
where l.address = “Newcastle” or
from Lecturers as l
from Lecturers l

4. Database Entry Points
Named objects are entry points to the database (same as table or view names in RDBs).
Class extents are usually used to refer to in OQL queries.
Some frequently used objects can be assigned unique names e.g. CEIS a named Department object or AdvDB as named Unit object.
To use named objects, you don’t have to write a query in select-from-where form. You can simply write:
CEIS.staff
which returns all staff member objects in the school of computing and mathematics.
Students
which returns a set of all Student objects in the database.

5. Retrieving data from multiple objects
Without using Joins
select struct(LName:l.name, DName:l.worksFor.name)
from l in Lecturers
The query contains an implicit join based on the relationship that exists between Lecturer and Department object types and due to the path expression l.worksFor.name. However, the user does not need to tell the OQL compiler.
Using Joins
select struct(LName:l.name, DName:d.name)
from l in Lecturers, d in Departments
where l.worksFor = d
Here the user explicitly tells that a join should be performed on the basis of matching OIDs (l.worksFor and d denote an OID of a Department object).

6. Unnesting and Nesting Collections
Unnesting a collection
select struct(LName:l.name, SName:s.name)
from l in Lecturers, s in l.tutees
The query retrieves names of lecturers and their tutees in pairs.
The query iterates over the collection Lecturers via the variable l; then iterates over l.tutees (a set of Student objects) via the variable s; then projects out name from l and name from s. The type of the query result is bag<LName:string, SName:string>.
Nesting a collection
select struct(LName:l.name,
SNames:(select s.name from s in l.tutees)
from l in Lecturers
The query retrieves for every lecturer, his/her name and all his/her tutees names.
Here instead of unnesting l.tutees, the query iterates over l.tutees via s and projects out name attribute and then constructs a collection out of it. The type of the query is
bag<LName:string, SNames:bag<string>>.

7. Aggregate Functions
A query to list module name, the number of lecturers teaching on the module and the number of students taking the module:
select struct(Uname:u.name,
Tno: count(u.taughtBy),
Sno: count(u.takenBy))
from u in Units
The query calls the count() aggregate function over the collections taughtBy and takenBy to return the required numbers.
There is no need to do group by as the collections are integral parts of module objects.
On a similar relational database, you would require to join several tables and use group by to answer a similar question in SQL, which may not be that efficient and easily expressed as the above OQL query.

8. Language Binding
Extends an OOPL (C++, Java, Smalltalk) with ODL and OML (Object Manipulation Language) for building OODB applications.
ODL binding defines how ODL constructs are mapped onto an OOPL.
OML binding defines how objects are created, deleted, and modified in an OOPL.
An OOPL may embed OQL where results returned by OQL queries can be manipulated by OOPL.

9. C++ ODL ODL C++ class Department (extent Departments)
{ attribute string name;
relationship set<Lecturer> staff inverse Lecturer::worksFor;
relationship set<Course)> offers inverse Course::offeredBy; };
ODL
const char _worksFor[ ] = “worksFor”;
const char _offeredBy[ ] = “offeredBy”;
class Department : d_Object
{ public:
d_String name;
d_Rel_Set <Lecturer, _worksFor> staff;
d_Rel_Set <Course, _offeredBy> offers; };
d_Extent<Department> Departments(DB1); // for extent
// DB1 is the database name
C++
for inverse relationships

10. C++ OML Object Creation Object Modification Object Deletion
d_Ref<Student> S = new(DB1, “Student”) Student;
// creates a new Student object in DB1 database
d_Ref<Lecturer> L = new(DB1, “Lecturer”) Lecturer;
// creates a new Lecturer object in DB1 database
Object Modification
S->name = “Richard Spring”; // modifies name attribute of Student S
S->address = “Durham”; // similarly
L->room = 103; // modifies room attribute of Lecturer L
L->tutees.insert_element(&S); // establishes a relationship
// between Lecturer L and Student S
Object Deletion
L.delete_object(); // deletes the Lecturer object from the database

11. C++ OQL Define variables for the query result
d_Bag<d_Ref<Lecturer>> CEIS_Staff;
d_Bag<d_Ref<Student>> ToonArmy;
Create an instance of type d_OQL_Query
d_OQL_Query q (“select l from l in Lecturers where l.worksFor.name = $1);
d_OQL_Query q1 (“select s from s in Students where s.address = “Newcastle”);
Modify the query with Parameters
q << “CEIS”; // Imposes a restriction on the query
Execute the query
d_oql_execute(q, CEIS_Staff);
// executes the query q and stores the result into CEIS_Staff variable
d_oql_execute(q1, ToonArmy);
// executes the query q1 and stores the result into ToonArmy variable

12. Summary An overview of ODMG standard
An introduction to the Object Data Model
A little bit of ODL
Introduction to OQL
Introduction to language binding