更複雜的Collection Property.

下面的範例中, 定義了三個Entity X, Y, Z. 而且X的定義中含有一個具有複雜的Collection型別的Property data3, 在存取data3之中的元素時, 需注意操作執行的先後順序或限制條件. 例如一個Entity, 若在其內有Collection Property, 其中仍含有元素時, 則該Entity不能被刪除, 因為這種行為會違反了資料表中的參考限制條件.
package com.logntw.eva.cdm.cdc;

import java.util.List;
import java.util.SortedMap;

import junit.framework.Assert;

import org.junit.Test;

import com.logntw.eva.anno.orm.Entity;
import com.logntw.eva.anno.orm.Id;
import com.logntw.eva.cdm.accessor.CollectionAccessor;
import com.logntw.eva.orm.DBConnectionProvider;
import com.logntw.eva.orm.EagerToGet;
import com.logntw.eva.orm.ORMappers;
import com.logntw.eva.orm.defo.DefaultTableCreator;
import com.logntw.eva.orm.defo.DefoORMappers;
import com.logntw.eva.orm.defo.conn.HSQLDB_1_8ConnectionProvider;

public class SortedMapConverterTest4
{
  @Entity
  public interface X
  {
    // if having a collection , there must be a primary key !!    
    @Id
    int getId1();
    void setId1(int id1);
            
    int getData1();
    void setData1(int data1);
    
    int getData2();
    void setData2(int data2);
    
    SortedMap<Y,SortedMap<Y,Z>> getData3();
    void setData3(SortedMap<Y,SortedMap<Y,Z>> data3);
  }
  
  @Entity
  public interface Y extends Comparable
  {
    // if having a collection , there must be a primary key !!      
    @Id
    int getId1();
    void setId1(int id1);
            
    int getData1();
    void setData1(int data1);
  }

  
  @Entity
  public interface Z
  {
    // if having a collection , there must be a primary key !!      
    @Id
    int getId1();
    void setId1(int id1);
            
    int getData1();
    void setData1(int data1);
  }

  @Test
  public void testResultSetAccessorImpRead2() throws Exception
  {            
    DBConnectionProvider provider = new HSQLDB_1_8ConnectionProvider("SortedMapConverterTest4");    
    ORMappers mappers = DefoORMappers.getInstance(provider);

    DefaultTableCreator.create(mappers, Y.class);
    DefaultTableCreator.create(mappers, Z.class);
    DefaultTableCreator.create(mappers, X.class);
    
    mappers.open();
    
    try
    {      
      X x1 = mappers.newObject(X.class);  
      x1.setId1(55);
      x1.setData1(77);    
      x1.setData2(99);
      X x2 = mappers.newObject(X.class);    
      x2.setId1(5);
      x2.setData1(7);    
      x2.setData2(9);
            
      mappers.insert(x1);
      mappers.insert(x2);  
      
      
      Y y1 = mappers.newObject(Y.class);  
      y1.setId1(1);
      y1.setData1(2);          
      Y y2 = mappers.newObject(Y.class);
      y2.setId1(3);
      y2.setData1(4);
      Y y3 = mappers.newObject(Y.class);
      y3.setId1(5);
      y3.setData1(6);
      
      mappers.insert(y1);
      mappers.insert(y2);
      mappers.insert(y3);
      
      Z z1 = mappers.newObject(Z.class);  
      z1.setId1(7);
      z1.setData1(8);          
      Z z2 = mappers.newObject(Z.class);
      z2.setId1(9);
      z2.setData1(10);
      Z z3 = mappers.newObject(Z.class);
      z3.setId1(11);
      z3.setData1(12);
      
      mappers.insert(z1);
      mappers.insert(z2);
      mappers.insert(z3);
      
      CollectionAccessor<SortedMap<Y,SortedMap<Y,Z>>> accessor = mappers.getMapper(X.class).getCollectionAccessor("data3");    
      CollectionAccessor<SortedMap<Y,Z>> accessor2 = mappers.getMapper(X.class).getCollectionMapper("data3").getCollectionAccessor("val");
      
      SortedMap<Y,SortedMap<Y,Z>> xm1 = accessor.createCollection(x1);
      SortedMap<Y,SortedMap<Y,Z>> xm2 = accessor.createCollection(x2);
      
      SortedMap<Y,Z> xmm1 = accessor2.createCollection(xm1);
      SortedMap<Y,Z> xmm2 = accessor2.createCollection(xm2);
      
      xm1.put(y1, xmm1);
      xm2.put(y1, xmm2);

      xmm1.put(y1, z1);
      xmm1.put(y2, z2);

      xmm2.put(y1, z1);
      xmm2.put(y2, z2);
      xmm2.put(y3, z3);
      
      List<X> list = mappers.select(EagerToGet.ENTITY, X.class);
      Assert.assertEquals(list.size(), 2);
      
      
      X x3 = list.get(0);
      X x4 = list.get(1);
      int x3DataY1Size = x3.getData3().get(y1).size();
      if(x3DataY1Size == 2)
      {
        Assert.assertTrue(x4.getData3().get(y1).size() == 3);
        Assert.assertEquals(x4.getData3().get(y1).get(y1), z1);
        Assert.assertEquals(x4.getData3().get(y1).get(y2), z2);  
        Assert.assertEquals(x4.getData3().get(y1).get(y3), z3);
                
        Assert.assertEquals(x3.getData3().get(y1).get(y1), z1);  
        Assert.assertEquals(x3.getData3().get(y1).get(y2), z2);  
      }
      else
      {
        Assert.assertTrue(x4.getData3().get(y1).size() == 2);
        Assert.assertEquals(x3.getData3().get(y1).get(y1), z1);
        Assert.assertEquals(x3.getData3().get(y1).get(y2), z2);  
        Assert.assertEquals(x3.getData3().get(y1).get(y3), z3);
                
        Assert.assertEquals(x4.getData3().get(y1).get(y1), z1);  
        Assert.assertEquals(x4.getData3().get(y1).get(y2), z2);  
        
      }

      xmm1.clear();
      xmm2.remove(y2);
            
      list = mappers.select(EagerToGet.ENTITY, X.class);
      Assert.assertEquals(list.size(), 2);
      
      X x5 = list.get(0);
      X x6 = list.get(1);
      int x5DataY1Size = x5.getData3().get(y1).size();
      if(x5DataY1Size == 0)
      {
        Assert.assertTrue(x6.getData3().get(y1).size() == 2);  
                
        Assert.assertEquals(x6.getData3().get(y1).get(y1), z1);  
        Assert.assertEquals(x6.getData3().get(y1).get(y2), null);
        Assert.assertEquals(x6.getData3().get(y1).get(y3), z3);  
        
        x6.getData3().get(y1).remove(y1);
        x6.getData3().get(y1).remove(y3);
        
        x6.getData3().remove(y1);
        x5.getData3().remove(y1);
      }
      else
      {
        Assert.assertTrue(x6.getData3().get(y1).size() == 0);  
        
        Assert.assertEquals(x5.getData3().get(y1).get(y1), z1);  
        Assert.assertEquals(x5.getData3().get(y1).get(y2), null);
        Assert.assertEquals(x5.getData3().get(y1).get(y3), z3);  
        
        x5.getData3().get(y1).remove(y1);
        x5.getData3().get(y1).remove(y3);
        
        x5.getData3().remove(y1);
        x6.getData3().remove(y1);
      }
              
      mappers.getMapper(X.class).deleteAll();
      mappers.getMapper(Y.class).deleteAll();      
      mappers.getMapper(Z.class).deleteAll();      
      
      list = mappers.select(EagerToGet.ENTITY, X.class);
      Assert.assertEquals(list.size(),0);  
      
    }
    finally
    {      
      mappers.close();
      DefaultTableCreator.drop(mappers, X.class);
      DefaultTableCreator.drop(mappers, Z.class);
      DefaultTableCreator.drop(mappers, Y.class);      
    }
  }
}