Using doctrine with symfony 1.2 (2/4) - inheritance

Publié le 8 janvier 2009 par greg

Hello, this is time for the second article on Doctrine with symfony about inheritance this time. As I am used to Postgresql's inheritance mechanism, I was curious as Doctrine proposes 3 ways to create inheritance with your objects model :

simple inheritance
concrete inheritance
column aggregation inheritance

Let's (again) take an example: we want to create an application for a show that rents bikes, motorcycles and maybe more. We can say, our shop rents vehicules. All of the vehicules can be one of bike, motorcycle, car or whatever. We can easily understand a car is different from a bike and they do not have the same caracteristics.

The first step is to create 2 tables, one vehicle and one bicycle table:
config/doctrine/schema.yml:

 Vehicle:
 tableName: vehicle
 actAs: [Timestampable]
 columns:
 ref: { type: char(6), primary: true }
 brand: { type: varchar(255), notnull: true }
 Bicycle:
 inheritance: { type: simple, extends: Vehicle }
 columns:
 bike_type: { type: enum, values: [city, mountain, race], default: city, notnull: true }
 gears: { type: integer(32), default: 1, notnull: true }
 seats: { type: integer(4), default: 1, notnull: true }
 checks:
 gears_min: gears > 0
 seats_min: seats >

We see here, we have defined a simple inheritance. So what did Doctrine ?
data/sql/schema.sql:

 CREATE TABLE vehicle (
 ref CHAR(6),
 brand VARCHAR(255) NOT NULL,
 bike_type VARCHAR(255) DEFAULT 'city' NOT NULL,
 gears BIGINT DEFAULT 1 NOT NULL,
 seats INT DEFAULT 1 NOT NULL,
 created_at TIMESTAMP without time zone,
 updated_at TIMESTAMP without time zone,
 PRIMARY KEY(ref)
 );

(Our check statements do no appear) It sounds rather limited but let's see what we can do with that, assuming we add 2 bikes in the database using fixtures:

 ./symfony doctrine:dql "SELECT * FROM Bicycle"
 >> doctrine executing dql query
 DQL: SELECT * FROM Bicycle
 found 2 results
 -
 ref: BK0478
 brand: peugeot
 bike_type: city
 gears: '4'
 seats: 1
 created_at: '2009-01-04 17:18:25'
 updated_at: '2009-01-04 17:18:25'
 -
 ref: BK0734
 brand: raleigh
 bike_type: mountain
 gears: '21'
 seats: 1
 created_at: '2009-01-04 17:18:25'
 updated_at: '2009-01-04 17:18:25

This isn't really an inheritance mechanism because the children doesn't inherit from its parent. It is more like the parent get richer with every child classes. This may work with very simple cases because in this application, the motorcycle may have columns with «not null» attributes that bikes will never comply with. This isn't really what we are looking for.

Let's change our schema to use the concrete inhéritance :
config/doctrine/schema.yml:

 Bicycle:
 inheritance: { type: concrete, extends: Vehicle }

Launche the build-all-reload and see what we have:
data/sql/schema.sql:

 CREATE TABLE vehicle (
 ref CHAR(6),
 brand VARCHAR(255) NOT NULL,
 created_at TIMESTAMP without time zone,
 updated_at TIMESTAMP without time zone,
 PRIMARY KEY(ref)
 );
 
 CREATE TABLE bicycle (
 ref CHAR(6),
 brand VARCHAR(255) NOT NULL,
 bike_type VARCHAR(255) DEFAULT 'city' NOT NULL,
 gears BIGINT DEFAULT 1 NOT NULL,
 seats INT DEFAULT 1 NOT NULL,
 created_at TIMESTAMP without time zone,
 updated_at TIMESTAMP without time zone,
 PRIMARY KEY(ref),
 CHECK (gears > 0),
 CHECK (seats > 0)
 );

It sounds like Doctrine has created two tables and wants to handle the inheritance by itself. Let's see what we have once the fixtures are loaded:
In our database:

 dbtest=> \d
 List of relations
 Schema | Name | Type | Owner
 --------+---------+-------+-------
 public | bicycle | table | toto
 public | vehicle | table | toto
 (2 rows)
 
 dbtest=> SELECT * FROM vehicle ;
 ref | brand | created_at | updated_at
 -----+-------+------------+------------
 (0 rows)
 
 
 
 dbtest=> SELECT * FROM bicycle ;
 ref | brand | bike_type | gears | seats | created_at | updated_at
 --------+---------+-----------+-------+-------+---------------------+---------------------
 BK0478 | peugeot | city | 4 | 1 | 2009-01-04 17:25:26 | 2009-01-04 17:25:26
 BK0734 | raleigh | mountain | 21 | 1 | 2009-01-04 17:25:26 | 2009-01-04 17:25:26
 (2 rows)

We can see we have 2 bikes but it also appears we have no vehicules ! So Doctrine does not handle the inheritance by itself, if we want to have 2 bikes and also say we have 2 vehicles we have to overload the Bicycle definition. The other solution is to declare the Vehicle as an abstract class:
config/doctrine/schema.yml:

 Vehicle:
 tableName: vehicle
 abstract: true

But this seems not to work (or I missunderstood the doc) because the table definition is still present in the SQL...

Anyway, I am now able to create a motorbike table adding the following to
config/doctrine/schema.yml:

 Motorcycle:
 inheritance: { type: concrete, extends: Vehicle }
 columns:
 type: { type: enum, values: [scooter, roadster, city], notnull: true, default: scooter }
 cylinder: { type: integer, notnull: true }
 plate: { type: string(11), notnull: true, unique: true }
 checks:
 cylinder_min: cylinder > 0
 plate_format: plate ~ \'[0-9]{1,4}\\-[A-Z]{2,3}\\-[0-9]{1,2}\

So after adding some fixtures I have 2 tables with independant data:

 dbtest=> SELECT * FROM motorcycle ;
 ref | brand | type | cylinder | plate | created_at | updated_at
 --------+--------+---------+----------+------------+---------------------+---------------------
 MB1837 | vespa | scooter | 125 | 324-MA-92 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
 MB6430 | yamaha | city | 750 | 2301-ZC-60 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
 (2 rows)
 
 
 
 dbtest=> SELECT * FROM bicycle ;
 
 ref | brand | bike_type | gears | seats | created_at | updated_at
 --------+---------+-----------+-------+-------+---------------------+---------------------
 BK0478 | peugeot | city | 4 | 1 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
 BK0734 | raleigh | mountain | 21 | 1 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
 (2 rows)
 
 
 
 dbtest=> SELECT * FROM vehicle ;
 ref | brand | created_at | updated_at
 -----+-------+------------+------------
 (0 rows)

If I try to count the vehicles I have with a DQL query it would not be as simple as:

 test$ ./symfony doctrine:dql "SELECT * FROM Vehicle"
 >> doctrine executing dql query
 DQL: SELECT * FROM Vehicle
 >> doctrine no results found

Let's then try the last type of inheritance: the columns aggregation.

 Bicycle:
 inheritance: { type: column_aggregation, extends: Vehicle, keyField: type, keyValue: bicycle }

For the bicycles and

 Motorcycle:
 inheritance: { type: column_aggregation, extends: Vehicle, keyField: type, keyValue: motorbike }

for the motorbikes.

Then doctrine complains it cannot load the data because constraints. If I go and have a check at the database I see there is only one table with all the columns but with an extra column named type and none of my sql constraints:

 dbtest=> SELECT * FROM vehicle ;
 ref | brand | type | bike_type | gears | seats | cylinder | plate | created_at | updated_at
 -----+-------+------+-----------+-------+-------+----------+-------+------------+------------
 (0 rows)

At the end of this testing phase I am a bit confused about what these types of inheritance stand for. I am not sure I will ever use one of those. I was expecting Doctrine to have like a PHP implementation of what Postgresql's inheritance system is without the problems it has ... or maybe I am missing something :o)