test2.cpp

一个通用的oracle OCI开发程序包

#include <iostream.h>

#ifndef sparc
#include <process.h>
#endif

#include <stdlib.h>
#include <stdio.h>

#include <math.h>
#include <time.h>
#include <memory>

#include <stdinc.h>

void memtest();
void memcontroller();
void memtest2(OCIType* tdo);
void memtestwrap();
void copy();
void nested();
void lob_bind_dynamic();
void t();
void p16(int objects);
void q16_array_pin();
void q16_select();
void plsql();
void test_date(COCIDate d, char* what);
void lb();
void lb2();
void delobj();
void _1to1();
void lb3(char* corp,char* code);
void std_string();

COCISession s1;
COCISession s2;


#define TIME(Func)\
  if(true){\
  clock_t start,finish;\
  double duration;\
  start = clock();\
  Func;\
  finish = clock();\
  duration = (double)(finish - start) / CLOCKS_PER_SEC;\
  cout << "\nClock ticks: " << (finish - start) << endl;\
  cout << "Duration: " << duration << endl;\
  }

// Useful macro for ignore errors (e.g. table does not exist when dropping)
#define IGNORE_ERROR(Func)\
try{Func;}catch(CBaseException&){}

int main(int argc, char ** argv)
{
  try
  {
    //s1.connect("l1480/l1480",OCI_OBJECT | OCI_THREADED);
    s1.connect("null_test/null_test",OCI_OBJECT | OCI_THREADED);
    //s1.connect("copy/copy@ukp8619",OCI_OBJECT | OCI_THREADED);
    //memtest();
    //memcontroller();
    //memtestwrap();
    //copy();
    //nested();
    //lob_bind_dynamic();
    //t();
    //TIME(p16(atoi(argv[1])));
    //TIME(q16_array_pin());
    //TIME(q16());
    //TIME(q16_select());
    //plsql();
    COCIDate d(s1);
    test_date(d,"Tests null date");
    d = COCIDate::sys_date(s1);
    test_date(d,"Tests not null date");
    //lb2();
    //delobj();
    //_1to1();
    //lb3(argv[1],argv[2]);
    //std_string();

  }
  catch(CBaseException& exc)
  {
	  char* buff = exc.GetError();
 	  cout << "Errortext: " << buff << endl;
    long e = exc.GetErrorCode();
    cout << "Errorcode: " << e << endl;
  } 
  catch(int)
  {
  }

  return 0;

}


void memtest1()
{
  COCICache c(s1);
  c.set_size(1000);

  std::vector<COCIRef> refs(1000,COCIRef(s1));
  char buf[(240+1)*1000];
  COCITransaction t(s1);

  COCIStatement stmt(s1);
  stmt = "select name from b r";
  


  for(int i = 0; i < 4000; i++)
  {
    
    t.start();
    stmt.define(1,buf,240,1000);

    cout << "Iter: " << i << endl;

    
    if(stmt.execute())
    {
      do
      {
        for(int i = 0; i < stmt.rows_fetched(); i++)
        {
          //cout << refs[i].to_hex().c_str() << endl;
        }
      }while(stmt.fetch());
    }

    
    t.commit();
    c.free();
  }
}

void memcontroller()
{
  char *type_name_array[1];
  type_name_array[0] = (char*)"A_T";
  ub4 type_name_lengths[1];
  type_name_lengths[0] = 3;
  OCIType *tdo_array[1];

  CHECK(s1.get_error(), OCITypeArrayByName(s1.get_env(), s1.get_error(), s1.get_svc(),1,
                                              0, 0,
                                			        (const text **) type_name_array,
		                                          type_name_lengths, 
                                              (CONST text **) 0, 0,  
                                              OCI_DURATION_DEFAULT, OCI_TYPEGET_ALL, tdo_array));

    for(int i = 0; i < 10000; i++)
    {
      memtest2(tdo_array[0]);
      cout << "done q" << i << endl;
    } 
}


int f()
{
  return 0;
}

void memtest2(OCIType* tdo)
{

  COCITransaction t(s1);
  //t.start();

  //COCIType type(s1,"A_T");


  void* instance = 0;

  CHECK( s1.get_error(), OCIObjectNew(s1.get_env(),
       s1.get_error(),
       s1.get_svc(),
       OCI_TYPECODE_OBJECT,
       (OCIType*)tdo, 
       0, 
       OCI_DURATION_TRANS, FALSE, (dvoid **) &instance) );

  CHECK(s1.get_error(),
        OCIObjectFree(s1.get_env(), s1.get_error(), (dvoid *) instance, OCI_OBJECTFREE_FORCE));

  t.commit();


}

void memtestwrap()
{

  COCITransaction t(s1);
  int objects = 1000;


  std::vector<COCIObject> a_objs(objects,COCIObject(s1,COCITable(s1,"A"),COCIType(s1,"A_T")));
  std::vector<COCIObject> b_objs(objects,COCIObject(s1,COCITable(s1,"B"),COCIType(s1,"B_T")));
  std::vector<COCIObject> c_objs(objects,COCIObject(s1,COCITable(s1,"C"),COCIType(s1,"C_T")));
  std::vector<COCIObject> d_objs(objects,COCIObject(s1,COCITable(s1,"D"),COCIType(s1,"D_T")));
  std::vector<COCIObject> e_objs(objects,COCIObject(s1,COCITable(s1,"E"),COCIType(s1,"E_T")));

  for(int i = 0; i < objects; i++)
  {
    cout << i << endl;
    e_objs[i].set("E_ID",i+(3*objects));
    e_objs[i].set("NAME","Hello World");
    a_objs[i].set("ID",i);
    a_objs[i].set("DOB",COCIDate::sys_date(s1));
    a_objs[i].set("E",e_objs[i]);
    b_objs[i].set("ID",i+objects);
    c_objs[i].set("ID",i+(2*objects));
    b_objs[i].set("A",a_objs[i].get_ref());
    c_objs[i].set("A",a_objs[i].get_ref());
    d_objs[i].set("A",a_objs[i].get_ref());

  }
  /*COCIObject a(s1, COCITable(s1, "A"), COCIType(s1, "A_T"));
  //COCIObject b(s1, COCITable(s1, "B"), COCIType(s1, "B_T"));
  COCIObject c(s1, COCITable(s1, "C"), COCIType(s1, "C_T"));
  //COCIObject d(s1, COCITable(s1, "D"), COCIType(s1, "D_T"));
  COCIObject e(s1, COCITable(s1, "E"), COCIType(s1, "E_T"));
  COCIObject f(s1, COCITable(s1, "F"), COCIType(s1, "F_T"));
  f.set("STR","Hello E!!");

  COCINestedTable<COCIObject> c_t_1(s1, COCIType(s1, "C_T_1"));
  c.set("A",a.get_ref());
  c.set("ID",2000);
  c_t_1.append(c);
  f.set("C",c_t_1);



  /*COCIObject a(s1, COCIType(s1, "A_T"));
  COCIObject b(s1, COCIType(s1, "B_T"));
  COCIObject c(s1, COCIType(s1, "C_T"));
  COCIObject d(s1, COCIType(s1, "D_T"));*/

  /*a.set("ID",666);
  a.set("DOB",COCIDate::sys_date(s1));
  e.set("E_ID",1000);
  e.set("NAME","Hello World");
  f.set("E",e.get_ref());
  a.set("E",e);

  /*a.set("ID",666);
  b.set("ID",667);
  c.set("ID",668);
  b.set("A",a.get_ref());
  c.set("A",a.get_ref());
  d.set("A",a.get_ref());*/

  t.commit();
}

void copy()
{

  COCITransaction t(s1);

  COCIObject a(s1, COCITable(s1, "A"), COCIType(s1, "A_T"));
  COCIObject b(s1, COCITable(s1, "B"), COCIType(s1, "B_T"));

  a.set("ID",666);
  b.set("NAME","Hello World");

  COCIRef b_rcopy(b.get_ref());
  a.set("B",b_rcopy);
  b.set("A",a.get_ref());

  //COCIObject b_copy(b);
  COCIObject a_copy(a);

  t.commit();

}

void nested()
{
  COCITransaction t(s1);

  COCIObject a(s1, COCITable(s1, "A"), COCIType(s1, "A_T"));
  COCINestedTable<COCIObject> embed(s1, COCIType(s1, "B_T_1"));
  COCIObject b(s1, COCITable(s1, "B"), COCIType(s1,"B_T"));
  b.set("NAME","Hello World");
  b.set("DOB",COCIDate::sys_date(s1));

  OCIType* tdo = 0;
  void* instance = a.get_attr_instance("B",tdo);

  CHECK(s1.get_error(), 
      OCICollAppend(s1.get_env(), 
                    s1.get_error(), 
                    b.get_instance(), 
                    b.get_null_struct(), 
                    (OCIColl*)*(void**)instance));


  boolean exists = false;
  dvoid* elem = (dvoid*)0;
  dvoid* elemind = (dvoid*)0;
  CHECK(s1.get_error(),
        OCICollGetElem(s1.get_env(),
                       s1.get_error(),
                       (OCIColl*)*(void**)instance,
                       0,
                       &exists,
                       &elem,
                       &elemind));

  COCINestedTable<COCIObject> e(s1, *(void**)instance, COCIType(s1, "B_T_1"));
  a.set("B",e);

/*  COCINestedTable<COCIObject> e(s1, *(void**)instance, COCIType(s1, "B_T_1"));
  e.append(b);*/

  //((COCINestedTable<COCIObject>)a.get("B")).append(b);


  t.commit();

}

void lob_bind_dynamic()
{
  // create table l (lob clob);
  COCITransaction t(s1);

  COCIStatement stmt(s1);
  COCICLob l(s1);
  l.make_empty();
  stmt = "insert into l values (:input) returning lob into :output";
  stmt.bind(":input",l);
  stmt.bind(":output",l);
  if(stmt.execute())
  {
    l << "Hello " << "World";
  }

  t.commit();

}

void t()
{
  COCICache c(s1);

  COCITransaction t(s1);

  for(int i = 0; i < 10000; i++)
  {
    COCIObject z(s1, COCITable(s1, "Z"), COCIType(s1, "Z_T"));
    z.set("ID",i);
    //z.flush();
    cout << i << endl;
    if((i % 1000) == 0)
    {
      cout << "Cache free" << endl;
      c.flush();
    }
  }

  t.commit();
}

class t_pers
{
public:
  t_pers():o(COCIObject(s1,COCITable(s1, "O"), COCIType(s1, "O_T")))
  {
      int i = 1;  o.set("A1",i);
      o.set("A2",i);
      o.set("A3",i);
      o.set("A4",i);
      o.set("A5",i);
      o.set("A6",i);
      o.set("A7",i);
      o.set("A8",i);
      o.set("A9",i);
      o.set("A10",i);
      o.set("A11",i);
      o.set("A12",i);
      o.set("A13",i);
      o.set("A14",i);
      o.set("A15",i);
      o.set("A16",i);
  }
  t_pers& operator = (const COCIObject& src)
  {
    o = src;
    return *this;

  }

  COCIObject o;
};

class t_trans
{
public:
  t_trans():o(COCIObject(s1, COCITable(s1, "O"), COCIType(s1, "O_T")))
  {
      i++;  o.set("A1",i);
      o.set("A2",i);
      o.set("A3",i);
      o.set("A4",i);
      o.set("A5",i);
      o.set("A6",i);
      o.set("A7",i);
      o.set("A8",i);
      o.set("A9",i);
      o.set("A10",i);
      o.set("A11",i);
      o.set("A12",i);
      o.set("A13",i);
      o.set("A14",i);
      o.set("A15",i);
      o.set("A16",i);
  }
  t_trans& operator = (const COCIObject& src)
  {
    o = src;
    return *this;

  }
  static int i;

  COCIObject o;
};

int t_trans::i = 0;