Commit sequence

Question

Hi all,
I'd like to know a little more on a DB commit process. In my database,
Table A is parent of Table B. And Table B is parent of Table C. The following code will attempt to fill each of these table with respect to their relationship:
class Update {
  DAOFactory mySQL = null;
  ServiceTable_A serviceA = null;
  ServiceTable_B serviceB= null
  ServiceTable_C serviceC =null;
  public Update(){
      mySQL = DAOFactory.getDAOFactory(DAOFactory.MYSQL);
     serviceA = mySQL.getServiceA();
     serviceB = mySQL.getServiceB();
     serviceC = mySQL.getServiceC();
  public void addToA(Person A){
       int status = serviceA.insert(A);
  public void addToB(Relative B){
       int status = serviceB.insert(B);
  public void addToC(Address C){
       int status = serviceC.insert(C);
  public boolean success(){
       if(status > -1){
           mySQL.commit();  //see snapshot of commit method below
      else
           mySQL.rollback();
class PerformUpdate(){
    Update update = null;
    Person A = null;
    Relative B = null;
    Address C = null;
    public PerformUpdate(Update d){
         update= d;
    public void performNewPerson(Person A, Relative B, Address C){
          update.addToA(A);
         update.addToB(B);
         update.addToC(C);
class View{
    private boolean UPDATE = true;
    private PerformUpdate perf = null;
   public void constructObjsFromInput(){
         // I construct Person A, Relative B, Address C objs here
   public void executeAction(){
        constructObjsFromInput();
        if(UPDATE){
            perf = new PerformUpdate(new Update());
            perf.performNewPerson(A, B, C);
  //HERE IS A SNAPSHOT OF THE COMMIT METHOD IN MYSQL FACTORY
  public void commit(){
     if( ! connection.isAutoCommit()){
            connection.commit();
            connection.setAutoCommit(true);
                  dbUtils.close(connection);  //dbUtils will close connections in
                                                                   //finally block
  }serviceA, serviceB, and serviceC have their own preparedStatements that
executes insert commands.
Assume that none of them fail, it's still important that serviceA commits first, followed by serviceB, then serviceC based on their relationship.
Is there anyway that the sequence of execution triggered by the commit gets jacked up on the way to the DB ? I tested this situation several times.
Two situations occur wih the same set of data:
1. Table B, child of Table A, cannot be updated because of foreign key constraints. It is as if, serviceB attempted to be updated before Table A did !
2. Table C, child of Table B, cannot be updated because of foreign key constraints. It is as if, Table A update occured first, then Table C's followed by table B.
Are we guaranteed that preparedStmts will be committed with respect to the time they were called ?
or does it depend the weight of their query ?
or it's just up to the JVM to give resources to whichever one? If so, do we have a way to force the sequence to happen in one way ?
Thanks

Answer 1

also check for any key assumptions that may not be
valid. What is the foriegn key constraint? Is it an
autonumber that you are making an assumption about
that when it turns out to be not what you think blows
it all up?That's exactly right. The DB keys are auto-generated, auto-incremented.
With this in mind, if i want to add a new field to a Table , I compute the next number sequence of the key. In that manner:
class ServiceToTable_A implements ServiceA_DAO{
    private Connection con = null;
    public ServiceToTable_A(Connection con){
          this.con = con
    // The body structure of this method is the same for all other daos
   // except that I query the appropriate table for a given service
    public int nextSeq(int increment){
         int key = 0;
         Statement stat = null;
         ResultSet keySet = null;
          try{
                  String query= "Select * from table A";
                  stat = con.createStatement();
                  keySet = stat.executeQuery(query);
                  keySet.last();   //move cursor to last row
                  key = keySet.getInt("person_id");
          }catch(Exception n){
               //log error             
           finally{
              stat.close();
              keySet.close();
          return key + inc;
   class Loading {
      DAOFactory mySQL = null;
     ServiceTable_A serviceA = null;
     ServiceTable_B serviceB= null
     ServiceTable_C serviceC =null;
     public Loading(){
           mySQL = DAOFactory.getDAOFactory(DAOFactory.MYSQL);
          serviceA = mySQL.getServiceA();
          serviceB = mySQL.getServiceB();
          serviceC = mySQL.getServiceC();
      public int getNextPersonId(int inc){
              return serviceA.nextSeq(inc);
      public int getNextRelativeId(int inc){
              return serviceB.nextSeq(inc);
   class View{
        Person A;
        Relative B;
        Loading load = new Loading();
        public void constructObjects(){
                  A = new Person();
                  //Construct A from input fields
                  B.setParentKey(load.getNextPersonId(1));
                  //construct B from input fields              
                  C.setParentKey(load.getNextRelativeId(1);
            //construct C from input fields              
}As you said, i'll do some more testing to isolate what's going on. It seems very odd that the two outcomes alternate like that. Or I may just have the coolest DB on earth