看我做的数据库包装器

yulihua49

DAU可以支持插入带RETURNING子句了：
http://blog.chinaunix.net/u3/92831/showart.php?id=2205055
   在设计表结构时，往往一个表没有合适的主键，常设计一个自增列，或default uuid列，插入数据时可以不插这个列。这个列往往用于外连接，可是插入后可能就找不到哪个是刚插入的了。此时必须使用带RETURNING子句的插入语句，在插入完成后立即得到键值。
    新的DAU/SDBC系统支持插入操作带RETURNING子句，定义一个或多个返回列。

[ 本帖最后由 yulihua49 于 2010-3-31 09:55 编辑 ]

yulihua49

测试一下批量插入，在这个表存储过程单条插入100000条大约是3.6秒。
OCI批量插入，10条：1.2秒
100条：0.45秒。
1000条：0.27秒
单条：8.7秒。
批量还是有巨大优势，但不好管理。
下例在DAU环境下自己调sqlora完成：可以看到不用包装器，程序还是挺繁的，尤其是当列比较多时，而且还不通用。

1. 
   
2. tuxticket@jgbticket:~/test> cat ti.c
   
3. /*************************************
   
4. 
   
5. create table T (
   
6.         I1 number(6),
   
7.         I2 number(6),
   
8.         I3 number(6),
   
9.         I4 number(6)
   
10. );
    
11. 
    
12. PK:
    
13. create or replace procedure ti
    
14. IS
    
15. I   integer;
    
16. BEGIN
    
17.      FOR I IN 1..100000 LOOP
    
18.       INSERT INTO T VALUES (I,I,I,I);
    
19.      END LOOP;
    
20. END;
    
21. /
    
22. 测试批量插入
    
23. ***************************************/
    
24. 
    
25. #include <DAU.h>
    
26. 
    
27. #define BATCH 1000
    
28. 
    
29. typedef struct {
    
30.         int i1;
    
31.         int i2;
    
32.         int i3;
    
33.         int i4;
    
34.         short i1_ind;
    
35.         short i2_ind;
    
36.         short i3_ind;
    
37.         short i4_ind;
    
38. } ti_stu;
    
39. 
    
40. main(int argc,char *argv[])
    
41. {
    
42. int i,j,num=0;
    
43. int ret;
    
44. T_SQL_Connect SQL_Connect;
    
45. INT64 now;
    
46. sqlo_stmt_handle_t cursor;
    
47. char *result=0,stmt[1024];
    
48. ti_stu ti[BATCH];
    
49. 
    
50.         if(argc>1) ret=envcfg(argv[1]);
    
51. 
    
52.         ret=db_open(&SQL_Connect);
    
53.         if(ret) {
    
54.                 printf("OPEN_Database %s,err=%d.%s\n",
    
55.                         SQL_Connect.DBOWN,
    
56.                         SQL_Connect.Errno,
    
57.                         SQL_Connect.ErrMsg);
    
58.                 return 1;
    
59.         }
    
60. 
    
61.         for(i=0;i<BATCH;i++)
    
62.                 ti[i].i1_ind=ti[i].i2_ind=ti[i].i3_ind=ti[i].i4_ind=0;
    
63.         sprintf(stmt,"INSERT INTO %s.T (I1,I2,I3,I4) VALUES(:1,:2,:3,:4)",SQL_Connect.DBOWN);
    
64.         cursor=sqlo_prepare(SQL_Connect.dbh,stmt);
    
65.         if(cursor < 0) {
    
66.                 ___SQL_GetError(&SQL_Connect);
    
67.                 printf("sqlo_prepare err=%d,%s\n",
    
68.                         SQL_Connect.Errno,
    
69.                         SQL_Connect.ErrMsg);
    
70.                 ___SQL_CloseDatabase__(&SQL_Connect);
    
71.                 return 2;
    
72.         }
    
73. printf("stmt=%s\n",stmt);
    
74.         if((0>sqlo_bind_by_pos2(cursor,1,SQLOT_INT,&ti[0].i1,sizeof(int),&ti[0].i1_ind,0,sizeof(ti_stu))) ||
    
75.            (0>sqlo_bind_by_pos2(cursor,2,SQLOT_INT,&ti[0].i2,sizeof(int),&ti[0].i2_ind,0,sizeof(ti_stu))) ||
    
76.            (0>sqlo_bind_by_pos2(cursor,3,SQLOT_INT,&ti[0].i3,sizeof(int),&ti[0].i3_ind,0,sizeof(ti_stu))) ||
    
77.            (0>sqlo_bind_by_pos2(cursor,4,SQLOT_INT,&ti[0].i4,sizeof(int),&ti[0].i4_ind,0,sizeof(ti_stu)))) {
    
78.                 ___SQL_GetError(&SQL_Connect);
    
79.                 printf("sqlo_bind err=%d,%s\n",
    
80.                         SQL_Connect.Errno,
    
81.                         SQL_Connect.ErrMsg);
    
82.                 ___SQL_Close__(&SQL_Connect,cursor);
    
83.                 ___SQL_CloseDatabase__(&SQL_Connect);
    
84.                 return 3;
    
85.         }
    
86. 
    
87.         j=0;
    
88.         now=now_usec();
    
89.         for(i=0;i<100000;i++) {
    
90.                 ti[j].i1=ti[j].i2=ti[j].i3=ti[j].i4=i;
    
91.                 if(BATCH==++j) {
    
92.                         ret=sqlo_execute(cursor,j);
    
93.                                 j=0;
    
94.                         if(ret) {
    
95.                                 ___SQL_GetError(&SQL_Connect);
    
96.                                 printf("sqlo_execute err=%d,%s\n",
    
97.                                         SQL_Connect.Errno,
    
98.                                         SQL_Connect.ErrMsg);
    
99.                                 break;
    
100.                         }
     
101.                         num+=sqlo_prows(cursor);
     
102.                 }
     
103.         }
     
104.         printf("insert %dRec's num=%d,TIMEVAL=%lldus\n",i,num,now_usec()-now);
     
105. 
     
106.         strcpy(stmt,"TICKET.TI");
     
107.         now=now_usec();
     
108.         ret=ORA_Rpc(&SQL_Connect,stmt,&result);
     
109.         printf("ORA_Rpc:return=%d,TIMEVAL=%lldus\n",ret,now_usec()-now);
     
110. 
     
111.         ___SQL_Transaction__(&SQL_Connect,TRANROLLBACK);
     
112.         ___SQL_CloseDatabase__(&SQL_Connect);
     
113. }
     
114. tuxticket@jgbticket:~/test> ./ti ld.ini
     
115. stmt=INSERT INTO TICKET.T (I1,I2,I3,I4) VALUES(:1,:2,:3,:4)
     
116. insert 100000Rec's num=100000,TIMEVAL=269855us
     
117. ORA_Rpc:return=0,TIMEVAL=3628331us
     

复制代码

[ 本帖最后由 yulihua49 于 2010-4-2 15:12 编辑 ]

yulihua49

我最近做了一个程序，线程池服务器，驻留程序，为很多客户端服务。
其中把很多大家都要查询的内容都放到内存，减少了90%的语句执行。
臭显一下：要查找站名字典，调此函数结果在DP里。
int find_station(DAU *DP,T_Tree **root,char *stmt)
{
DG10_STATION_stu  stnnode;
T_Tree *tp;
int ret;
char *p;

        stnnode=*(DG10_STATION_stu *)DP->srm.rec;
        tp=BB_Tree_Find(*root,&stnnode,sizeof(stnnode),stn_cmp);
        if(tp) {
                *(DG10_STATION_stu *)DP->srm.rec=*(DG10_STATION_stu *)tp->Content;
                return 0;
        }
        if(DP->cursor<0) {
                p=DAU_mk_where(DP,"station_name",stmt);
                p=stpcpy(p," AND station_start_date <= :station_start_date"
                           " AND station_stop_date >= :station_start_date"
                           " AND a.city_code=b.city_code"
                           " AND city_start_date <= :station_start_date"
                           " AND city_stop_date >= :station_start_date");
        }
        if(0!=(ret=DAU_prepare(DP,stmt)))  return -1;
        else if(DAU_next(DP))  return -2;

        *root=BB_Tree_Add(*root,DP->srm.rec,sizeof(stnnode),stn_cmp,0);
        return 0;
}
数据在中间服务器缓存，极大的减少了数据库服务器的压力。

因为没有写表里的列名，所以表结构的改变与程序无关，别动我用到的几个列就行。存储过程没这个好处，表结构改变程序一定要修改的。

用C或其他编程语言处理业务逻辑，并不是简单的谁快谁慢的问题，能够利用到语言提供的许多资源与数据资源的深度整合，能够极大的方便编程和提高系统效率，这是存储过程难以达到的。

再声明一次，我不反对存储过程，而且DAU支持调用存储过程。

[ 本帖最后由 yulihua49 于 2010-8-3 11:40 编辑 ]

newkid

CACHE的思想不是自古有之吗？你这个有什么特别？
你如何判断缓存需要刷新？还是永远不刷新？
11G的RECULT_CACHE自动管理你的结果集，自动刷新。
在你的例子中，如果不同客户端传入不同的:station_start_date, 你保留几个缓存的拷贝？
谁说表结构改变就一定要修改存储过程？很多时候只是重新编译而已。
你的做法无非就是SELECT * (虽然你没有写SELECT *, 但是你的程序是所有列都读取，不管需不需要)，这其实是很浪费的。

tom0732

原帖由 yulihua49 于 2010-4-2 13:12 发表
测试一下批量插入，在这个表存储过程单条插入100000条大约是3.6秒。
OCI批量插入，10条：1.2秒
100条：0.45秒。
1000条：0.27秒
单条：8.7秒。
批量还是有巨大优势，但不好管理。
下例在DAU环境下自己调sqlora完成：可以看到不用包装器，程序还是挺繁的，尤其是当列比较多时，而且还不通用。


tuxticket@jgbticket:~/test> cat ti.c
/*************************************

create table T (
        I1 number(6),
        I2 number(6),
        I3 number(6),
        I4 number(6)
);

PK:
create or replace procedure ti
IS
I   integer;
BEGIN
     FOR I IN 1..100000 LOOP
      INSERT INTO T VALUES (I,I,I,I);
     END LOOP;
END;
/
测试批量插入
***************************************/

#include

#define BATCH 1000

typedef struct {
        int i1;
        int i2;
        int i3;
        int i4;
        short i1_ind;
        short i2_ind;
        short i3_ind;
        short i4_ind;
} ti_stu;

main(int argc,char *argv[])
{
int i,j,num=0;
int ret;
T_SQL_Connect SQL_Connect;
INT64 now;
sqlo_stmt_handle_t cursor;
char *result=0,stmt[1024];
ti_stu ti;

        if(argc>1) ret=envcfg(argv[1]);

        ret=db_open(&SQL_Connect);
        if(ret) {
                printf("OPEN_Database %s,err=%d.%s\n",
                        SQL_Connect.DBOWN,
                        SQL_Connect.Errno,
                        SQL_Connect.ErrMsg);
                return 1;
        }

        for(i=0;isqlo_bind_by_pos2(cursor,1,SQLOT_INT,&ti[0].i1,sizeof(int),&ti[0].i1_ind,0,sizeof(ti_stu))) ||
           (0>sqlo_bind_by_pos2(cursor,2,SQLOT_INT,&ti[0].i2,sizeof(int),&ti[0].i2_ind,0,sizeof(ti_stu))) ||
           (0>sqlo_bind_by_pos2(cursor,3,SQLOT_INT,&ti[0].i3,sizeof(int),&ti[0].i3_ind,0,sizeof(ti_stu))) ||
           (0>sqlo_bind_by_pos2(cursor,4,SQLOT_INT,&ti[0].i4,sizeof(int),&ti[0].i4_ind,0,sizeof(ti_stu)))) {
                ___SQL_GetError(&SQL_Connect);
                printf("sqlo_bind err=%d,%s\n",
                        SQL_Connect.Errno,
                        SQL_Connect.ErrMsg);
                ___SQL_Close__(&SQL_Connect,cursor);
                ___SQL_CloseDatabase__(&SQL_Connect);
                return 3;
        }

        j=0;
        now=now_usec();
        for(i=0;i ./ti ld.ini
stmt=INSERT INTO TICKET.T (I1,I2,I3,I4) VALUES(:1,:2,:3,:4)
insert 100000Rec's num=100000,TIMEVAL=269855us
ORA_Rpc:return=0,TIMEVAL=3628331us

有没有试过批量绑定:

1. 
   
2. SQL> DECLARE
   
3. I   integer;
   
4. BEGIN
   
5.      FOR I IN 1..100000 LOOP
   
6.       INSERT INTO T VALUES (I,I,I,I);
   
7.      END LOOP;
   
8. commit;
   
9. END;
   
10. /  2    3    4    5    6    7    8    9
    
11. PL/SQL procedure successfully completed.
    
12. Elapsed: 00:00:08.39
    
13. SQL> DECLARE
    
14.   2  TYPE NumList IS TABLE OF number;
    
15.   3  listno  NumList;
    
16.   4  BEGIN
    
17.   5  select rownum BULK COLLECT INTO listno from dual connect by  rownum<100001;
    
18.   6  FORALL i IN listno.first..listno.last
    
19.   7  insert into T values(listno(i),listno(i),listno(i),listno(i));
    
20.   8  commit;
    
21.   9  END;
    
22. 10  /
    
23. PL/SQL procedure successfully completed.
    
24. Elapsed: 00:00:00.43
    
25. SQL>

复制代码

yulihua49

原帖由 newkid 于 2010-8-3 23:08 发表
CACHE的思想不是自古有之吗？你这个有什么特别？
你如何判断缓存需要刷新？还是永远不刷新？
11G的RECULT_CACHE自动管理你的结果集，自动刷新。
在你的例子中，如果不同客户端传入不同的:station_start_date, 你保留几个缓存的拷贝？
谁说表结构改变就一定要修改存储过程？很多时候只是重新编译而已。
你的做法无非就是SELECT * (虽然你没有写SELECT *, 但是你的程序是所有列都读取，不管需不需要)，这其实是很浪费的。

新版DAU可以任意选择列或去除列：set_col(..,..,"列名，列名，。。。。");或except_col(..,..,"列名,列名,,,");
我认为第二种方法较好，数据比较独立，如果后来修改表，某些列没了，这语句也不错，不必修改。如果增加列，就自动被包含在选择集里。

其实你仔细看，我上边的例子实际上是两表连接，b表只用了4个列（结果集1个，条件3个），并非全部。（b表十几个列呢）。
功能不讨论了，存储过程能做的DAU都能做，反之亦然。
cache的有效性的确是问题。
现在在上海，有一个11G的DB平台和分离的中间件服务器。
只要调用服务器，速度就慢，只有减少数据库的调用，即使在数据库服务器不忙的情况。
只要给数据库一点压力，它的CPU立即上升到90%以上。所以只能尽量不调用数据库。

1000个用户压力，中间件CPU不到20%，数据库90%以上。都是8CPU的HP小型机。
26ms的调用在1000用户下延长到3秒。想提高响应能力，唯一的办法是减小数据库开销。尽量将开销转移到中间件。
这个数值就是26*1000/8,为什么不是/16呢？因为负载不均衡，中间件的8个CPU没用上。
为什么不把中间件的CPU也加到数据库？因为数据库是安腾64的，中间件是X86的，比较廉价。这就是说我所希望的廉价中间件分担昂贵的数据库，实现起来很不容易的。
数据库再怎么cache，也就是用内存和CPU取代IO。但CPU负担已经很重了。

[ 本帖最后由 yulihua49 于 2010-8-4 23:55 编辑 ]

newkid

“延长到3秒”的调用都在做什么？说不定你没优化好。

yulihua49

原帖由 newkid 于 2010-8-4 23:55 发表
“延长到3秒”的调用都在做什么？说不定你没优化好。

1个人时响应时间是26ms，比较稳定。
1000个人同时来，的平均响应时间是3秒左右，数据库服务器的8个CPU，平均90%，比较均衡。
中间件8个CPU，平均<20%，且不均衡。
1000客户端，32个进程，32数据库个连接，每个客户端连续10个调用。实际进行了10000次调用。


数据库CPU已经90%，响应时间已经符合理论计算，即：这系统的吞吐量已经达到极限。
若想增加系统能力，最好增加数据库的CPU数量或RAC。

[ 本帖最后由 yulihua49 于 2010-8-5 08:50 编辑 ]

newkid

你有没想过这些负担可能是你的编程方法引起的？如果用存储过程，你只需和数据库打一次交道；用你的方法，不得不频繁访问。
1000个连接是实际SESSION的数量？有没有用连接池？有时候你需要的物理连接并没那么多，几个客户可以共享，平均响应时间反而降低。
还是老规矩：把你的需求亮出来，我来写存储过程，你看看我的做法比你差多少！

newkid

刚刚看到你补充的内容，32个物理连接也太少了吧！你这10次调用，其实一次就够了。我问你绑定变量值修改之后，CACHE会不会复制新的拷贝而你没有答复，我猜想你的缓存都是静态的字典表之类的。这些缓存解决不了什么问题，DB的BLOCK缓存就够好了，何况我还可以在PGA里面用PLSQL的全局数组。