Werner Guttmann werner DOT guttmann AT gmx DOT net

# Castor JDO code samples

## Introduction

This document provides object mapping examples and the corresponding Java objects and DDL for the database table.

### Java class files

The following fragment shows the Java class declaration for the Product class:

    package myapp;

    public class Product {

        private int       _id;

        private String    _name;

        private float     _price;

        private ProductGroup _group;

        public int getId() { ... }

        public void setId( int anId ) { ... }

        public String getName() { ... }

        public void setName( String aName ) { ... }

        public float getPrice() { ... }

        public void setPrice( float aPrice ) { ... }

        public ProductGroup getProductGroup() { ... }

        public void setProductGroup( ProductGroup aProductGroup ) { ... }
    }

The following fragment shows the Java class declaration for the ProductGroup class:

    public class ProductGroup {

        private int       _id;

        private String    _name;

        public int getId() { ... }

        public void setId( int id ) { ... }

        public String getName() { ... }

        public void setName( String name ) { ... }

    }

### DDL

The following sections show the DDL for the relational database tables PROD, PROD_GROUP, and PROD_DETAIL:

`PROD`:

    create table prod (
      id        int           not null,
      name      varchar(200)  not null,
      price     numeric(18,2) not null,
      group_id  int           not null
    );

`PROD_GROUP`:

    create table prod_group (
      id        int           not null,
      name      varchar(200)  not null
    );

`PROD_DETAIL`:

    create table prod_detail (
      id        int           not null,
      prod_id   int           not null,
      name      varchar(200)  not null
    );

### Object Mappings

The following code fragment shows the object mapping for the ProductGroup class:

    <?xml version="1.0"?>
    <!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Object Mapping DTD Version 1.0//EN"
                             "http://castor.org/mapping.dtd">
    <mapping>

      <class name="myapp.ProductGroup" identity="id">

        <description>Product group</description>

        <map-to table="prod_group" xml="group" />

        <field name="id" type="integer" >
          <sql name="id" type="integer"/>
        </field>

        <field name="name" type="string">
          <sql name="name" type="char" />
        </field>

      </class>

    </mapping>

As a result of that declaration, Castor JDO will create the following SQL statements for creating, deleting, loading and updating instances of ProductGroup:

    create: INSERT INTO prod_group (id, name) VALUES (?,?)
    delete: DELETE FROM prod_group WHERE id=?
    load:   SELECT prod_group.id, prod_group.name FROM prod_group WHERE prod_group.id=?;
    update: UPDATE prod_group SET name=? WHERE id=?

#### Read-only fields

To declare the name field read-only, the field definition above for the field name needs to be changed to:

      <class name="myapp.ProductGroup" identity="id">

        ...
        <field name="name" type="string">
          <sql name="name" type="char" read-only="true" />
        </field>

      </class>

As a result of that declaration, Castor JDO creates the following SQL statements for creating, deleting, loading and updating instances of ProductGroup:

    create: INSERT INTO prod_group (id) VALUES (?)
    delete: DELETE FROM prod_group WHERE id=?
    load:   SELECT prod_group.id, prod_group.name FROM prod_group WHERE prod_group.id=?;
    update: /* no statement will be generated */

#### Transient fields

To declare the name field transient with regards to persistence, above field definition for the field name needs to be changed to:

      <class name="myapp.ProductGroup" identity="id">

        ...
        <field name="name" type="string" >
          <sql name="name" type="char" transient="true" />
        </field>

      </class>

### Relations

#### 1:1 relation

The following code fragment shows the mapping file for the Product class. Apart from the simple field declarations, this includes a simple 1:1 relation between `Product` and `ProductGroup`, where every product instance is associated with a `ProductGroup`:

        <class name="myapp.Product" identity="id">

            <map-to table="prod" />

            <field name="id" type="integer">
                <sql name="id" type="integer" />
            </field>

            <field name="name" type="string">
                <sql name="name" type="char" />
            </field>

            <field name="price" type="float">
                <sql name="price" type="numeric" />
            </field>

            <field name="group" type="myapp.ProductGroup" >
                <sql name="group_id" />
            </field>

            <field name="details" type="myapp.ProductDetail"
                   collection="vector">
               <sql many-key="prod_id"/>
            </field>

            <field name="categories" type="myapp.Category" collection="vector">
               <sql name="category_id"
                    many-table="category_prod" many-key="prod_id" />
            </field>

        </class>

#### 1:M relation

The following code fragment shows (again) the mapping file for the Product class. The field definition highlighted shows how to declare a 1:M relation between `Product` and `ProductDetail`, where every product instance is made up of many `ProductDetails`:

        <class name="myapp.Product" identity="id">

            <map-to table="prod" />

            <field name="id" type="integer">
                <sql name="id" type="integer" />
            </field>

            <field name="name" type="string">
                <sql name="name" type="char" />
            </field>

            <field name="price" type="float">
                <sql name="price" type="numeric" />
            </field>

            <field name="group" type="myapp.ProductGroup" >
                <sql name="group_id" />
            </field>

            <field name="details" type="myapp.ProductDetail" collection="vector">
               <sql many-key="prod_id"/>
            </field>

            <field name="categories" type="myapp.Category" collection="vector">
               <sql name="category_id"
                    many-table="category_prod" many-key="prod_id" />
            </field>
        </class>

The following code fragment shows the corresponding mapping entry for the ProductDetail class that defines the second leg of the 1:M relation between `Product` and `ProductDetail`.

      <class name="myapp.ProductDetail" identity="id" depends="myapp.Product" >

        <description>Product detail</description>

        <map-to table="prod_detail" xml="detail" />

        <field name="id" type="integer">
          <sql name="id" type="integer"/>
        </field>

        <field name="name" type="string">
          <sql name="name" type="char"/>
        </field>

        <field name="product" type="myapp.Product">
          <sql name="prod_id" />
        </field>

      </class>

#### M:N relation

The following code fragment shows (again) the mapping file for the Product class. The field definition highlighted shows how to declare a M:N relation between `Product` and `ProductCategory`, where many products can be mapped to many product categories:

        <class name="myapp.Product" identity="id">

            <map-to table="prod" />

            <field name="id" type="integer">
                <sql name="id" type="integer" />
            </field>

            <field name="name" type="string">
                <sql name="name" type="char" />
            </field>

            <field name="price" type="float">
                <sql name="price" type="numeric" />
            </field>

            <field name="group" type="myapp.ProductGroup" >
                <sql name="group_id" />
            </field>

            <field name="details" type="myapp.ProductDetail" collection="vector">
               <sql many-key="prod_id">/>
            </field>

            <field name="categories" type="myapp.Category" collection="vector">
               <sql name="category_id"
                    many-table="category_prod" many-key="prod_id" />
            </field>

        </class>

The following code fragment shows the corresponding mapping entry for the ProductCategory class that defines the second leg of the M:N relation between `Product` and `Category`.

      <class name="myapp.Category" identity="id">

        <description>
            A product category, any number of products can belong to
            the same category, a product can belong to any number of
            categories.
        </description>

        <map-to table="category" xml="category" />

        <field name="id" type="integer">
          <sql name="id" type="integer"/>
        </field>

        <field name="name" type="string">
          <sql name="name" type="char"/>
        </field>

        <field name="products" type="myapp.Product" collection="vector">
          <sql name="prod_id"
               many-table="category_prod" many-key="category_id" />
        </field>

      </class>

### Extend relation & polymorphism

As of release 0.9.9, Castor supports polymorphic queries on extend hierarchies. (That is, hierarchies where some entities "extend" other entities.) To highlight this new feature, let's add two new classes to what we have currently.

    package myapp;

    public class Computer extends Product {

        private int       _id;

        private String    _make;

        public int getId() { ... }

        public void setId( int anId ) { ... }

        public String getmake() { ... }

        public void setMake( String aMake ) { ... }

    }

    public class Car extends Product {

        private int       _id;

        private Date    _registeredIn;

        public int getId() { ... }

        public void setId( int anId ) { ... }

        public Date getRegisteredIn() { ... }

        public void setRegisteredIn( Date aRegisteredIn ) { ... }
    }

The corresponding DDL statements for the relational database tables COMP and CAR would look as follows:

`COMP`:

    create table comp (
      id        int           not null,
      make      varchar(200)  not null
    );

`CAR`:

    create table car (
      id        int           not null,
      regIn     int           not null
    );

Based upon the mapping defined for the Product class as shown above, the following code fragment shows the mapping for the `Computer` and `Car` classes.

        <class name="myapp.Computer" extends="myapp.Product" identity="id">

            <map-to table="COMP" />

            <field name="id" type="integer">
                <sql name="id" type="integer" />
            </field>

            <field name="make" type="string">
                <sql name="make" type="char" />
            </field>

        </class>

        <class name="myapp.Car" extends="myapp.Product" identity="id">

            <map-to table="CAR" />

            <field name="id" type="integer">
                <sql name="id" type="integer" />
            </field>

            <field name="registeredIn" type="date">
                <sql name="regIn" type="long" />
            </field>

        </class>

Based upon this mapping, it is possible to execute the following OQL queries against this class model:

    OQLQuery query = d.getOQLQuery("SELECT c FROM myapp.Computer c");

To return all computers:

    OQLQuery query = d.getOQLQuery("SELECT c FROM myapp.Computer c WHERE c.make = $");

To return all computers of a particular make:

    OQLQuery query = d.getOQLQuery("SELECT p FROM myapp.Product p");

To return all products (where Castor will return the actual object instances, i.e. a `Computer` instance if the object returned by the query is of type `Computer` or a `Car` instance if the object returned by the query is of type `Car`):

    OQLQuery query = d.getOQLQuery("SELECT p FROM myapp.Product p WHERE p.group.name = $");

To return all products that belong to the specified product group (where Castor will return the actual object instances, i.e. a `Computer` instance if the object returned by the query is of type `Computer` or a `Car` instance if the object returned by the query is of type `Car`):

### OQL samples

Based upon above definitions, here are a few OQL sample queries that highlight various artifacts of the OQL support of Castor JDO.

To Be Written