Bean persistence with MentaBeans

Having the following database schema:

Beans:

public class Car {
    
    private int id;
    private String name;
    private Date year;
    
    private int engineId; // mentabean can inject directly in here...
    private Engine engine = null;
    
    // required by any ORM
    public Car() {
        
    }
    
    public Car(int id) {
        this.id = id;
    }
    
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    
    public Engine getEngine() {
        return engine;
    }
    
    // other getters and setter here
}

public class Engine {
    
    private int id;
    private String name;
    private int type;
    
    private List<Part> parts = null;
    
    // required by ORM
    public Engine() {
        
    }
    
    public Engine(int id) {
        this.id = id;
    }
    
    public void setParts(List<Part> parts) {
        this.parts = parts;
    }
    
    public List<Part> getParts() {
        return parts;
    }
    
    // other getters and setters here
}

public class Part {
    
    private int id;
    private String name;
    
    // required by ORM
    public Part() {
        
    }
    
    public Part(int id) {
        this.id = id;
    }
    
    // other getter and setters here
}

In the ApplicationManager:

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
    
    public void loadActions() {
        // actions here...
    }
    
    public void loadBeans() {
        
        // configure bean fields
        
        BeanConfig car = bean(Car.class, "Cars")
                .pk("id", DBTypes.AUTOINCREMENT)
                .field("name", DBTypes.STRING)
                .field("year", DBTypes.DATE)
                .field("engineId", "engin_id", DBTypes.INTEGER);
                
        BeanConfig engine = bean(Engine.class, "Engines")
                .pk("id", DBTypes.AUTOINCREMENT, "engin_id" /* = FK */)
                .field("name", DBTypes.STRING)
                .field("type", "industryType", DBTypes.INTEGER);
                
        BeanConfig part = bean(Part.class, "Parts")
                .pk("id", DBTypes.AUTOINCREMENT, "part_id" /* = FK */)
                .field("name", DBTypes.STRING);
                
        // configure bean relationships
        
        engine.join(Part.class, "EnginesParts"); // OneToMany relationship!
        
    }

public void init(Context application) {

filter(new ConnectionFilter(connHandler));
        
        filter(new IoCFilter());
        ioc("session", MySQLBeanSession.class); // or JdbcBeanSession for only ANSI SQL...

filter(new DIFilter()); 
        di("conn", Connection.class); // JdbcBeanSession needs a Connection !!!!

}
}

Loading beans:

public class BeanActionExample extends BaseAction {
    
    public String execute() throws Exception {
        
        BeanSession session = (BeanSession) input.getValue("session"); // ioc working here...
        
        Car car = new Car(1); // car id = 1 (PK)
        
        boolean loaded = session.load(car);
        
        if (loaded) {
            
            System.out.println("Car just loaded: " + car.getName());
            
        } else {
            
            throw new ActionException("Not possible to load car with id = " + car.getId());
            
        }
        
        // let's load the Engine for this Car (OneToOne relationship)
        
        Engine engine = new Engine(car.getEngineId());
        
        loaded = session.load(engine);
        
        if (loaded) {
            
            car.setEngine(engine); // set the engine of this car...
            
            System.out.println("Engine just loaded: " + engine.getName());
            
        } else {
            
            throw new ActionException("Not possible to load engine with the id = " + engine.getId());
            
        }
        
        // now let's load the list of Parts for the Motor (OneToMany relationship)
        
        List<Parts> parts = session.loadJoin(engine, Peca.class);
        
        engine.setParts(parts); // set the list of parts of this engine...
        
        System.out.println("Number of parts loaded: " + parts.size());
        
        // you can also load ONLY the ids...
        
        List<Integer> ids = session.loadJoinIds(engine, Peca.class);
        
        // you can also count the ids...
        
        int total = session.countJoin(engine, Peca.class);
        
        return SUCCESS;
    }
}

Inserting beans:

// You are using MYSQL and the id (PK) of Car is set as AUTOINCREMENT
        
        Car car = new Car(); // no PK (id) specified...
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Just inserted a car with id: " + car.getId());
        
        // You are using Oracle and the id (PK) of Car is set as SEQUENCE
        // in this case you must have a sequence created in your DB with the name seq_id_Cars (seq_COL_TABLE)
        
        Car car = new Car(); // no PK (id) specified...
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Just inserted a car with id: " + car.getId());
        
        // You want a database-independent approach, so you will provide an unique id somehow...
        // In this case you should configure the field as a regular INTEGER, not AUTOINCREMENT or SEQUENCE...
        
        int id = getUniqueId();
        
        Car car = new Car(id); // pass the id to your Car...
        u.setName("Parati");
        u.setYear(DateFormat.parse("21/01/2005"));
        
        session.insert(car);
        
        System.out.println("Just inserted a car with id: " + id);

Adding beans to a relationship: (OneToOne)

Adding beans to a relationshiop: (OneToMany)

Removing a bean from a relationshiop: (OneToMany)

Updating a bean:

Deleting a bean:

Loading lists: