操作JDBC的參數

操作JDBC的參數.

有直接使用JDBC API經驗的讀者, 在操作一些存取資料的物件, 例如PreparedStatement, ResultSet等物件時, 都有機會去隨時調整一些操作的參數, 例如fetchSize與QueryTimeout等參數. 但在使用了ORM工具後, 大部份的參數都會被包裝起來, 使用者無法接觸, 或是只能做一次性的設定.

但Eva_ORM仍能讓使用者去隨時更改這些設定. 在ORMappers型別所宣告的方法中, 在’與Connection相關’的組別裡, 我們可以看到在呼叫open方法時可以傳入一些參數, 而對於JDBC操作參數的設定就可以在此時進行.

Eva_ORM的設計中, 進行交易的能力是由JDBC API直接提供的, 透過直接操作ORMappers物件中的open()方法所得到的Connection物件, 使用者可自行設定交易層級, 並透過呼叫Connection物件的commit()與rollback()方法來結束交易.

除了JDBC中, 交易相關的API之外, 使用者也可以在查詢資料時, 傳入適當的鎖定參數來得到讀寫的相關鎖定.


package com.logntw.eva.orm.defo;



import java.sql.Connection;

import java.util.List;



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.bean.condition.ConditionObj;

import com.logntw.eva.condition.OP;

import com.logntw.eva.orm.DBConnectionProvider;

import com.logntw.eva.orm.EagerToGet;

import com.logntw.eva.orm.ORMappers;

import com.logntw.eva.orm.defo.conn.DerbyConnectionProvider;

import com.logntw.eva.sql.SelectOption;



public class DefoORMappersTesti

{

  @Entity

  public static interface X

  {  

    @Id

    int getInfId();

    void setInfId(int id);

    

    Y getField4a();

    void setField4a(Y field4a);

    

    Y getField5b();

    void setField5b(Y field5b);

    

  }

  

  @Entity

  public static interface Y

  {  

    @Id

    int getInf2Id();

    void setInf2Id(int id);

    

    Z getField1b();

    void setField1b(Z field1b);

  }

  

  @Entity

  public static interface Z

  {  

    @Id

    int getInf3Id();

    void setInf3Id(int id);

    

    float getField3b();

    void setField3b(float field3b);

  }



  @Test

  public void testDefoORMappersTesti() throws Exception

  {    

    DBConnectionProvider provider = new DerbyConnectionProvider("DefoORMappersTesti");    

    ORMappers mappers = DefoORMappers.getInstance(provider);

    

    DefaultTableCreator.create(mappers, Z.class);

    DefaultTableCreator.create(mappers, Y.class);

    DefaultTableCreator.create(mappers, X.class);

    

    final int FETCH_SIZE = 10; 

    Connection conn = mappers.open(FETCH_SIZE);

    conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

    

    try

    {  

      Z za = mappers.newObject(Z.class);

      za.setInf3Id(11);

      Z zb = mappers.newObject(Z.class);

      zb.setInf3Id(10);

      Z zc = mappers.newObject(Z.class);

      zc.setInf3Id(9);

      Z zd = mappers.newObject(Z.class);

      zd.setInf3Id(8);

      Z ze = mappers.newObject(Z.class);

      ze.setInf3Id(7);

      Z zf = mappers.newObject(Z.class);

      zf.setInf3Id(6);

      Z zg = mappers.newObject(Z.class);

      zg.setInf3Id(5);

      Z zh = mappers.newObject(Z.class);

      zh.setInf3Id(4);

      Z zi = mappers.newObject(Z.class);

      zi.setInf3Id(3);

      Z zj = mappers.newObject(Z.class);

      zj.setInf3Id(2);

      Z zk = mappers.newObject(Z.class);

      zk.setInf3Id(1);

      

      

      Y ya = mappers.newObject(Y.class);

      Y yb = mappers.newObject(Y.class);

      Y yc = mappers.newObject(Y.class);

      Y yd = mappers.newObject(Y.class);

      Y ye = mappers.newObject(Y.class);

      Y yf = mappers.newObject(Y.class);

      Y yg = mappers.newObject(Y.class);

      Y yh = mappers.newObject(Y.class);

      Y yi = mappers.newObject(Y.class);

      Y yj = mappers.newObject(Y.class);

      Y yk = mappers.newObject(Y.class);

      

      ya.setInf2Id(11);

      ya.setField1b(za);

      yb.setInf2Id(12);

      yb.setField1b(zb);

      yc.setInf2Id(13);

      yc.setField1b(zc);

      yd.setInf2Id(14);

      yd.setField1b(zd);

      ye.setInf2Id(15);

      ye.setField1b(ze);

      yf.setInf2Id(16);

      yf.setField1b(zf);

      yg.setInf2Id(17);

      yg.setField1b(zg);

      yh.setInf2Id(18);

      yh.setField1b(zh);

      yi.setInf2Id(19);

      yi.setField1b(zi);

      yj.setInf2Id(20);

      yj.setField1b(zj);

      yk.setInf2Id(21);

      yk.setField1b(zk);

      

      X xa = mappers.newObject(X.class);

      X xb = mappers.newObject(X.class);

      X xc = mappers.newObject(X.class);

      X xd = mappers.newObject(X.class);

      X xe = mappers.newObject(X.class);

      X xf = mappers.newObject(X.class);      



      xa.setInfId(51);

      xa.setField4a(ya); // < 10

      xa.setField5b(yb); // > 5

      xb.setInfId(52);

      xb.setField4a(yc);

      xb.setField5b(yd);

      xc.setInfId(53);

      xc.setField4a(ye);

      xc.setField5b(yf);

      xd.setInfId(54);

      xd.setField4a(yg);

      xd.setField5b(yh);

      xe.setInfId(55);

      xe.setField4a(yi);

      xe.setField5b(yj);

      xf.setInfId(56);

      xf.setField4a(yk); // 1!

      xf.setField5b(ya); // 11! also fit!!!

            

      mappers.insert(za, zb, zc, zd, ze, zf, zg, zh, zi, zj, zk);

      mappers.rollback();

      mappers.insert(za, zb, zc, zd, ze, zf, zg, zh, zi, zj, zk); 

      mappers.insert(ya, yb, yc, yd, ye, yf, yg, yh, yi, yj, yk);

      mappers.insert(xa, xb, xc, xd, xe, xf);

          

      Assert.assertEquals(mappers.count(Z.class), 11);

      Assert.assertEquals(mappers.count(Y.class), 11);

      Assert.assertEquals(mappers.count(X.class), 6);

      

      ConditionObj<X> cx = mappers.getMapper(X.class).newCondition();    

      ConditionObj<Y> cya = mappers.getMapper(Y.class).newCondition();

      ConditionObj<Y> cyb = mappers.getMapper(Y.class).newCondition();      

      ConditionObj<Z> cza = mappers.getMapper(Z.class).newCondition();

      ConditionObj<Z> czb = mappers.getMapper(Z.class).newCondition();

      

      ConditionObj<Z> inf3c = mappers.getMapper(Z.class).newCondition();

      inf3c.If(OP.LESS).setInf3Id(8);

      

      //Pessimistic Locking 

      List lock1 = mappers.select(true, EagerToGet.NONE, inf3c, SelectOption.WRITELOCK);      

      List lock2 = mappers.select(true, EagerToGet.NONE, inf3c, SelectOption.WRITELOCK);

            

      cza.If(OP.LESS).setInf3Id(10);

      czb.If(OP.GREATER).setInf3Id(5);

      cya.If(OP.THAT).setField1b(cza.This());

      cyb.If(OP.THAT).setField1b(czb.This());

      cx.If(OP.THAT).setField4a(cya.This());

      cx.If(OP.THAT).setField5b(cyb.This());

      

      Assert.assertEquals(mappers.count(true, cx), 3);

      List<X> rtn = mappers.select(true, EagerToGet.ENTITY, cx);

      Assert.assertEquals(rtn.size(), 3);      

      rtn = mappers.select(true, EagerToGet.NONE, cx);

      mappers.commit();

      Assert.assertEquals(rtn.size(), 3);

      

      mappers.delete(true, xa, xb, xc, xd, xe, xf);

      mappers.delete(true, ya, yb, yc, yd, ye, yf, yg, yh, yi, yj, yk);

      mappers.delete(true, za, zb, zc, zd, ze, zf, zg, zh, zi, zj, zk);

      mappers.commit();      

    }

    finally

    {          

      mappers.close();

      DefaultTableCreator.drop(mappers, X.class);

      DefaultTableCreator.drop(mappers, Y.class);

      DefaultTableCreator.drop(mappers, Z.class);      

    }    

  }  

}