Why generate object-oriented database schema

Question

Let me begin with an example:
public class Base
protected int id = 0;
protected String name = null;
public class Derived extends Base
protected int type = 0;
Derived class and Base class form an object-oriented inheritence. After
using SchemaToolTask, the following table definition is generated :
create table base
id INT NOT NULL,
name VARCHAR(255),
PRIMARY KEY (id)
create table derived
id INT NOT NULL,
type INT,
PRIMARY KEY (id)
Actually, RDBMS is ER-oriented. Every meaningful entity corresponds to a
database table. But in this example, maybe "Base" has no any meaning, just
for abstraction. So why we must generate this table ? Why cannot be
configurated to just generate
create table derived
id INT NOT NULL,
name VARCHAR(255),
type INT,
PRIMARY KEY (id)
This will not only avoid join operation in SELECT, but also reduce the table
size according to Base class.
Thanks
Liang Zhilong
EMail : [email protected]
Tel : [phone]
Fax : [phone]
PhotonicBridges Co., Ltd.
12F, 900 Yi Shan Rd., Shanghai 200233

Answer 1

As I said, this is quite high on our project plans.
On Wed, 25 Jun 2003 14:41:29 +0800, Liang Zhilong wrote:
I believe your concern is reasonable. However, in our application, the
operation you assumed( to find all base instances owned by class C) is
rare, so it'll be useful if my suggested mapping is taken as an option.
Moreover, we should not get better performance at the cost of worse
database schema. Kodo should have enough capacity to optimize database
operations. For example, to find all base instances owned by class C, kodo
should issue a "SELECT col1, col2 FROM a UNION SELECT col1, col2 FROM b".
"Stephen kim" <[email protected]>
??????:[email protected]...
This sort of mapping is on our project plan but know that there a number
of severe performance penalties that can happen with the mapping you
describe. If you desire to lack the join, a flat-class mapping is the
most efficient table structure.
Take for example the multiple classes problem:
base
|_ A
|_ B
which would result in table a and table b. Now try to do an ordering
query. You would issue 2 selects and then have to merge in memory. To
do any relation join, again you multiply the number of SQL statements by
the number of subclasses (e.g. to find all base instances owned by class
C, you would have to query against a and b).
On Wed, 25 Jun 2003 12:39:39 +0800, Liang Zhilong wrote:
Let me begin with an example:
public class Base
protected int id = 0;
protected String name = null;
public class Derived extends Base
protected int type = 0;
Derived class and Base class form an object-oriented inheritence.
After using SchemaToolTask, the following table definition is
generated :
create
table base
id INT NOT NULL,
name VARCHAR(255),
PRIMARY KEY (id)
create table derived
id INT NOT NULL,
type INT,
PRIMARY KEY (id)
Actually, RDBMS is ER-oriented. Every meaningful entity corresponds to
a database table. But in this example, maybe "Base" has no any
meaning,just
for abstraction. So why we must generate this table ? Why cannot be
configurated to just generate
create table derived
id INT NOT NULL,
name VARCHAR(255),
type INT,
PRIMARY KEY (id)
This will not only avoid join operation in SELECT, but also reduce the
table size according to Base class.
Thanks
Liang Zhilong
EMail : [email protected]
Tel : [phone]
Fax : [phone]
PhotonicBridges Co., Ltd.
12F, 900 Yi Shan Rd., Shanghai 200233--
Steve Kim
[email protected]
SolarMetric Inc.
http://www.solarmetric.com
Steve Kim
[email protected]
SolarMetric Inc.
http://www.solarmetric.com