Create a custom type - which, other than data types, can include member functions (defined in two parts, the data and the function declarations, and the body containing the function definitions).
Create the table:
CREATE TABLE( person_typ pobject, ... )
Inserting the data is done this way:
INSERT INTO object_table VALUES ( 'second insert',
person_typ (51, 'donald', 'duck', 'firstname.lastname@example.org', '66-650-555-0125'));
Notice the implicit constructor.
To call a method:
SELECT o.pobject.get_idno() from object_table o
This is cool. But usually objects are used in code. So how is the client code/databaset object chasm bridged over?
These objects should be stored alone, without relational data (row objects as opposed to column objects as in the example above).
CREATE TABLE person_obj_table OF person_typ;
Scanning the object table:
DECLARE person person_typ;
SELECT VALUE(p) INTO person FROM person_obj_table p WHERE p.idno = 101;
Pointers to objects are supported via the REF type.
You can use a SELECT INTO to load a specific row object into a object variable.
You can implement database functions, procedures, or member methods of an object
type in PL/SQL, Java, C, or .NET as external procedures. This is a way to have the objects execute code defined externally. Only PL/SQL and Java code is stored in the database.
As far as consuming objects externally, one way is by the means of using untyped structures or by using a wizard to create strongly typed (Java) classes:
Object views, where you define a filter that interprets the rows in a table as an object, is an interesting innovation.
So does this really solve the impedance problem? It's not like you define an object in C# then persist it in the database, then deserialize it in the application again and call its methods. It's more like, you define an object in the database, and with some manual work you can map between it and a custom class you define in Java. You can define some of its methods in C# (using the Oracle Database Extensions for .NET) - how is that for multiple indirections?
The question is really, where do you want your code to execute. In the case discussed above, (defining member functions in .NET) Oracle acts as a CLR host for the .NET runtime; not unlike the way SQL Server external procedures (written in C and compiled as DLL's) used to run in an external process space. So the code executes outside the (physical) database process, but still inside a (logical) database layer. I still can't escape a nagging feeling that this is as database-centric a view of the application as they come. Usually the design of an application starts with actors modeling, etc, and the data layer is something that does not come into play until the end. Ideally, from an application designer's perspective, as I mentioned above, you should be able to just persist an object somehow to the database, and instantiate/deserialize it from the data layer/the abstract persistence without too much fuss. In the case of Cache this is made easier by the fact that the application layer coexists with the database layer and has access to the native objects (at least, if you use the Cache application development environment).
In the case of Oracle the separate spaces, database for storage/execution and application for execution pose the standard impedance discrepancy problem, which I am not sure is in any way eased by the OO features of the database.
An ideal solution? Maybe database functionality should be provided by the OS layer and the application development/execution environment should be able to take advantage of that.
Meanwhile, Microsoft's Entity Framework (actually, a rather logical development from ADO.NET) deals with this problem in the dev environment. What I have seen so far looks cool, just a couple of questions:
- can you start with the entities and generate (forward engineer) the database tables
- how is the schema versioned and how are evolutionary changes sync'ed
- how does the (obvious) overhead perform when there are hundreds of tables, mappings, etc.
Incidentally, using the Oracle ODP.NET driver in Visual Studio yields a much better experience with an Oracle database than using the standard MS drivers. You actually get a return (XML-formatted) when querying object tables (the MS driver reports it as 'unsupported data type') and can interact with the underlying database much more, including tuning advisor, deeper database object introspection, etc.
Even PostgreSQL (which I find quite cool actually) does portray itself as having object/relational features - table structures can be inherited.