侃一下关于程序的“柔性”

gyhgood

原帖由 newkid 于 2011-9-11 03:29 发表
“一批学生，半小时培训，就能写出不错的程序。
如果培训PL/SQL到一定水平需要多少时间？”
如果没学过任何编程的人呢？学习C和学习PLSQL哪个更快？

这点我非常赞同～肯定是PLSQL快！亲身体验

yulihua49

存储过程压力测试结果：

数据库服务器：8 core ORACLE 11G
交易服务器：  16core   SDBC服务器框架，32数据库连接
交易管理器：  16core   32服务器连接，最大客户端连接数10000
客户端：  LINUX C

1000个连接，每连接100次调用，共100000次调用
    总时间（S）      最小响应时间（us）   最大响应时间（us）    平均响应时间（s）    交易量（TPS）
存储过程：
    131.492          10319                856114                 0.7                 760.5
    130.616          10286                798802                 0.69                765.6
DAU：
    161.374           9396                1179848                0.99                619.67
    161.215           8399                1203900                0.99                620.28

总结：
从结果来看，存储过程效果比较好。
实际上，存储过程少读了两个表：all_cons_columns：未实现PRIMARY KEY功能。
                  自定义的表：pattern_col:未实现列格式修改功能。如日期变量的用户定义格式。确切的说，结果中日期数据是错的。
二者都读了的表是：
all_tab_columns和应用定义的表。

当然，你的程序比较专用，如果参数没提出PRIMARY KEY,你完全可以不读all_cons_columns表。
而我是通用程序，为所有DAU应用生成模板，不管这次用没用，我都要读all_cons_columns表。         

结论：
在大并发交易环境下，使用存储过程，与使用OCI接口，性能上没有本质差别。

yulihua49

原帖由 newkid 于 2011-9-11 03:29 发表

“就代码量而言，后边的接口代码加上PL/SQL的代码，量不低，含金量还很高，功能还有欠缺，何必要用PL/SQL呢？”
代码量没有多少，你忘了DAU那层全省掉了？我其实不喜欢这么做，我建议用PLSQL返回结果集，由你的C程序去包装成JSON. 你用C写个通用的读游标程序也不难。

DAU那点东西一点没省，为了帮你解析json参数，还增加了一段。

你看我的代码：有关于裸数据的处理。我试图把存储过程改成裸数据，没整明白，改不了。

[ 本帖最后由 yulihua49 于 2011-9-13 14:16 编辑 ]

yulihua49

原帖由 newkid 于 2011-9-11 03:29 发表 [url=http://www.itpub.net/redirect.php?goto=findpost&pid=18262820&ptid=1475665][quote]
如果没学过任何编程的人呢？学习C和学习PLSQL哪个更快？

我很奇怪，这里的人都搞些什么应用？光用存储过程就行了？

我们的应用可能没这么省事，一定会用一种程序语言的。现在不是JAVA就是C。
如果一个JAVA程序员，他一定是会用JDBC的。然后是，学PL/SQL快呢？还是学hibernate快？
如果C程序员，他不一定会用OCI。那么他要学OCI，再学PL/SQL(C调用PL/SQL也是要用OCI的）。还是学DAU快？
而且，学了OCI，写列名，一列一绑定。懒了，就写值，不绑定了。不用DAU，他能写出什么质量的程序？还不说极有可能这些程序内存泄露。

怎么可能雇佣没学过任何编程的人呢？

[ 本帖最后由 yulihua49 于 2011-9-13 15:47 编辑 ]

yulihua49

原帖由 newkid 于 2011-9-11 03:29 发表

“业务处理逻辑，在结构成员这个层次上使用列名，但在存取数据时，就可以少写或不写列名。”
你不是不写或少写，你是把这部分工作量转移到模版去了。如果自动模版，相当于SELECT *, 或SELECT *-X (这个-X表示去除某些列，是我杜撰的)；如果手动模版，则工作量比SQL还大，而且代码还不好读，你得很小心才知道怎么在模版外面加上WHERE。我敢打赌你的程序员大部分都用自动模版。这就引出一个问题，没有人用JOIN, 都是自己嵌套循环实现的。

不错。但手动模板也可以有元数据生成器帮助你。而且一次定义多次使用。（不仅是数据库访问用，在通讯打包拆包时，在读写文件时也用。这个模板最早是用于通讯打包拆包的，我给改成同时可用于数据库访问）
JOIN可以用，我承认，会用的人比较少。一懒就嵌套循环了。
当效率问题很临界的时候，他才去研究JOIN。真是，经常我去帮他们改JOIN模板。

代码不好读？脑袋里不要老想着SQL，你要读的是业务逻辑。读到调用DAO时，哦，这个DAU取得了它的数据。不要想怎么取。这样一个业务逻辑的大脉络就清晰了。
具体如何取得数据，单看DAO程序，你可以看到WHERE条件，这一般就够了。干嘛还非要看有哪些列呢？要看列，就看模板。这好像没什么难度。
即使你的程序罗列了列名，一般我也是不看的（好多人喜欢select *)，只看WHERE。
等我非要看列名时，一般是发生悲剧了，列好像是写错了。这种错误在模板系统里是完全可以避免的。

曾经，一个程序，几十个SQL语句，每个语句，百十来个列名。出点毛病，看的头都大了，改的手都软了。
那个PRO*C，不仅要写大批的列名，还要大批的 using...，into......还要对上号，改了前边改后边，哪差一点都不行。
看来大家对这个工作乐此不疲，那就不用模板也罢。


我觉得有些人似乎是SQL依赖症。

模板系统的优点就是代码好读。
我最前边的代码，APP层，不好读吗？那个存储过程好读？
哪位对C熟点的，给判断一下。

[ 本帖最后由 yulihua49 于 2011-9-13 15:17 编辑 ]

yulihua49

再给一个批量加载数据的例子：
这是用sqlldr加载的例子，每批1000条。
SQL> Disconnected from Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options
tjs@linux-ol8d:~/demo/sql> time ./ldtj.sh

SQL*Loader: Release 11.2.0.1.0 - Production on Tue Sep 13 17:11:38 2011

Copyright (c) 1982, 2009, Oracle and/or its affiliates.  All rights reserved.

Commit point reached - logical record count 1000
Commit point reached - logical record count 2000
Commit point reached - logical record count 3000
Commit point reached - logical record count 4000
Commit point reached - logical record count 5000
Commit point reached - logical record count 6000
Commit point reached - logical record count 7000
Commit point reached - logical record count 8000
Commit point reached - logical record count 9000
Commit point reached - logical record count 10000
Commit point reached - logical record count 11000
Commit point reached - logical record count 12000
Commit point reached - logical record count 13000
Commit point reached - logical record count 14000
Commit point reached - logical record count 15000
Commit point reached - logical record count 15104

real    0m1.067s
user    0m0.232s
sys     0m0.024s

yulihua49

这是用OCI批量加载的例子：
time ./t_OAD -f ld.ini tjrb <TJ.txt

real    0m0.589s
user    0m0.152s
sys     0m0.000s
成功多少条不知道？看日志：

1. 5 t_OAD:644 09/13 17:12'54 DB=RAILWAY5 t_OAD:644 09/13 17:12'54 loadfile:entry5 t_OAD:644 09/13 17:12'54 mksrm: tjrb
   
2. 5 t_OAD:644 09/13 17:12'54 bind_select:cursor=0,sqlo_prepare=SELECT /*+ result_cache */ c.table_name Fld_Tlb_Name,c.column_name  Fld_Column_Name,decode(data_type, 'CHAR',1, 'VARCHAR',1, 'VARCHAR2',1, 'DATE',129,'TIMESTAMP(6)',129,'FLOAT',8,'LONG',126, 'RAW',0, 'BINARY_DOUBLE',8,'BINARY_FLOAT',7, 'NUMBER',decode(nvl(DATA_SCALE,0),0,decode(nvl(data_precision,0), 0,257, 1,2, 2,2, 3,3, 4,3, 5,4, 6,4, 7,4, 8,4,9,4, 10,6, 11,6, 12,6, 13,6, 14,6, 15,6, 16,6, 17,6, 18,6, 257),8),257) Fld_Column_Type,decode(data_type, 'CHAR',data_length+1, 'VARCHAR',data_length+1,'VARCHAR2',data_length+1, 'DATE',20,'TIMESTAMP(6)',27,'FLOAT',8,'BINARY_DOUBLE',8,'BINARY_FLOAT',4,'LONG',-1, 'NUMBER', decode(nvl(DATA_SCALE,0),0,decode(nvl(data_precision,0), 0,40, 1,1, 2,1, 3,2, 4,2, 5,4, 6,4, 7,4, 8,4, 9,4, 10,8, 11,8, 12,8, 13,8, 14,8, 15,8, 16,8, 17,8, 18,8, data_precision+2),8),data_length) Fld_Column_Len,decode(data_type, 'CHAR',null, 'VARCHAR',null, 'VARCHAR2',null, 'DATE','YYYY-MM-DD HH24:MI:SS','TIMESTAMP(6)','YYYY-MM-DD HH24:MI:SS.FF6','FLOAT','%lg','LONG',null, 'BINARY_DOUBLE','%lg', 'BINARY_FLOAT','%g', 'NUMBER',decode(nvl(DATA_SCALE,0),0,null,'%'||TO_CHAR(data_precision+2)||'.'||TO_CHAR(DATA_SCALE)||'lf'),null) Fld_Format,k.position Fld_PK FROM all_tab_columns c, (select table_name,column_name,position from all_cons_columns where owner= :1 and table_name=:2 and position is not null) k  where c.table_name = k.table_name(+) and c.column_name = k.column_name(+) and c.owner = :3 and c.table_name=:4 order by c.table_name, c.column_id5 t_OAD:644 09/13 17:12'54 bind_select:cursor=0,sqlo_prepare=SELECT /*+ result_cache */ TAB_NAME,COL_NAME,COL_TYPE,COL_LEN,COL_FORMAT,PSEUDO_NAME FROM RAILWAY.PATTERN_COL WHERE TAB_NAME=:15 t_OAD:644 09/13 17:12'54 mkpk:TJDATE|UNIT|TABNAME|FLG|5 t_OAD:644 09/13 17:12'54 DAU_init ret=0,TIMEVAL=15696,reclen=440,size=440000
   
3. 5 t_OAD:644 09/13 17:12'54  OAD_mk_ins sth=0,INSERT INTO RAILWAY.tjrb (TJDATE,UNIT,TABNAME,FLG,DAT1,DAT2,DAT3,DAT4,DAT5,DAT6,DAT7,DAT8,DAT9,DAT10,DAT11,DAT12,DAT13,DAT14,DAT15,DAT16,DAT17,DAT18,DAT19,DAT20,DAT21,DAT22,DAT23,DAT24,DAT25,DAT26,DAT27,DAT28,DAT29,DAT30,DAT31,DAT32,DAT33,DAT34,DAT35,DAT36,DAT37,DAT38,DAT39,DAT40,DAT41,DAT42,DAT43,DAT44,DAT45,DAT46,DAT47,DAT48,DAT49,DAT50) VALUES (TO_DATE(:1,'YYYY-MM-DD'), :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, :14, :15, :16, :17, :18, :19, :20, :21, :22, :23, :24, :25, :26, :27, :28, :29, :30, :31, :32, :33, :34, :35, :36, :37, :38, :39, :40, :41, :42, :43, :44, :45, :46, :47, :48, :49, :50, :51, :52, :53, :54)
   
4. 2 t_OAD:644 09/13 17:12'54 loadfile:rows=15104,upd=0,TIMEVAL=453371
   
5. 2 t_OAD:644 09/13 17:12'54 loadasc:load 15104 rec's time=469335,buf=2006.01.31
   
6. 5 t_OAD:644 09/13 17:12'54 loadfile:15104 commit TIMEVAL=692,ret=0
   

复制代码

实际的读文件和插入的时间是rows=15104,upd=0,TIMEVAL=453371，0.453秒。SQLLDR内部的时间不知道。

[ 本帖最后由 yulihua49 于 2011-9-13 17:56 编辑 ]

yulihua49

原帖由 yulihua49 于 2011-9-13 17:14 发表
这是用OCI批量加载的例子：
time ./t_OAD -f ld.ini tjrb  

有说DAU程序不好懂的，看看这个，提意见。

1. cat t_OAD.c
   
2. #include <DAU.h>
   
3. //OAD=Oracle Array Describe
   
4. #include <OAD.h>
   
5. 
   
6. #define BATCH_NUM 1000
   
7. #define COMMIT_NUM 10
   
8. /* 插入重码就修改
   
9. 返回小于0出错，在SQL_Connect里
   
10. >=0插入的条数   
    
11. */
    
12. static int upd,loss;
    
13. //批量插入，遇重码修改之。在很多重码的场合，效率相当低
    
14. int insert_DAO(OAD *oad,int n,DAU *DP,char *stmt)
    
15. {
    
16. char *p;
    
17. int cc,ret,num;
    
18. int beg;
    
19. 
    
20.         beg=
    
21.         ret=num=0;
    
22.   do {
    
23.         ret=OAD_exec(oad,beg,n);// 实际插入就这一句话，其他都是处理出错的。
    
24.         if(ret>0) num+=ret;
    
25.         if(ret == n-beg) return num;
    
26.         if(oad->SQL_Connect->Errno != DUPKEY) {
    
27.                 ShowLog(1,"%s:OAD_exec err=%d,%s",__FUNCTION__,
    
28.                         oad->SQL_Connect->Errno,
    
29.                         oad->SQL_Connect->ErrMsg);
    
30.                 loss+=n-num;
    
31.                 return ret;
    
32.         }
    
33.         if(ret<0) ret=0;
    
34.         p=(char *)oad->recs;
    
35.         p+=(beg+ret)*(oad->reclen);
    
36.         memcpy(DP->srm.rec,p,oad->reclen);
    
37.         *stmt=0;
    
38.         cc=update_by_PK(DP,stmt);
    
39.         if(cc<=0) {
    
40.                 ShowLog(1,"%s update stmt=%s,err=%d,%s",__FUNCTION__,
    
41.                         stmt,
    
42.                         oad->SQL_Connect->Errno,
    
43.                         oad->SQL_Connect->ErrMsg);
    
44.                 loss += n-num;
    
45.                 return num;
    
46.         }
    
47.         upd+=cc;
    
48.         beg+=ret+1;
    
49. //ShowLog(5,"%s:beg=%d",__FUNCTION__,beg);
    
50.   } while(beg<n);
    
51.         return num;
    
52. }
    
53. //APP
    
54. int loadfile(T_SQL_Connect *SQL_Connect,char *tablename,FILE *ifd,FILE *ofd,int Pflg,char *buf,int buflen)
    
55. {
    
56. char *p,tabn[512];
    
57. DAU _DAU;
    
58. OAD oad;
    
59. int rows,ret;
    
60. int n,num,commit_num=0;
    
61. INT64 now;
    
62. 
    
63.     ShowLog(5,"loadfile:entry");
    
64.         now=now_usec();
    
65.     ret=DAU_init(&_DAU,SQL_Connect,tablename,0,0);
    
66.     if(ret) {
    
67.         ShowLog(1,"loadfile:DAU_init tabname=%s,ret=%d",tablename,ret);
    
68.         return -1;
    
69.     }
    
70.         num=_DAU.srm.tp[_DAU.srm.Aflg].offset;
    
71. char recs[BATCH_NUM * num];
    
72.         ShowLog(5,"DAU_init ret=%d,TIMEVAL=%ld,reclen=%d,size=%d",ret,now_usec()-now,num,sizeof(recs));
    
73.         OAD_init(&oad,&_DAU,recs,BATCH_NUM);
    
74.         upd=loss=0;
    
75.         *buf=0;
    
76.         ret=OAD_mk_ins(&oad,buf);        //生成插入语句。
    
77.         if(ret) {
    
78.                 ShowLog(1,"aft OAD_mk_ins:stmt=%s,err=%d,%s\n",buf,
    
79.                         SQL_Connect->Errno,
    
80.                         SQL_Connect->ErrMsg);
    
81.                         OAD_free(&oad);
    
82.                         DAU_free(&_DAU);
    
83.                         return -1;
    
84.         }
    
85.         n=num=0;
    
86.         now=now_usec();
    
87.     for(rows=0;!ferror(ifd);) {
    
88.         fgets(buf,buflen,ifd);//读出一行
    
89.         if(feof(ifd)) break;
    
90. 
    
91.                 OAD_pkg_dispack(&oad,n,buf,'|');//数据装入数组。
    
92.                 if(BATCH_NUM == ++n) {//够数了
    
93.                         ret=insert_DAO(&oad,n,&_DAU,buf); //插入数据库
    
94.                         n=0;
    
95.                         if(ret<0) break;
    
96.                         rows += ret;
    
97.                         if(++commit_num == COMMIT_NUM) {
    
98.                                 ___SQL_Transaction__(SQL_Connect,TRANCOMMIT);
    
99.                                 commit_num=0;
    
100.                         }
     
101.                 }
     
102.     }
     
103.         if(n) {//还有些零头。
     
104.                         ret=insert_DAO(&oad,n,&_DAU,buf);
     
105.                         if(ret>0) rows += ret;
     
106.                         n=0;
     
107.         }
     
108.     ShowLog(2,"loadfile:rows=%d,upd=%d,TIMEVAL=%lld",rows,upd,now_usec()-now);
     
109.         OAD_free(&oad);
     
110.     DAU_free(&_DAU);
     
111.     return rows;          //返回后，还会有一个 ___SQL_Transaction__(SQL_Connect,TRANCOMMIT);
     
112. 
     
113. }
     
114. 
     
115. 
     

复制代码

存储过程不能在不同的机器上加载文件，必须用一种语言来写。

思考题：如果没有DAU和OAD，你如何用OCI（OCCI，OCILib，PRO*C，JDBC，ODBC）写一个数组插入程序？
注意，某些数据可能出现NULL，要正确绑定。

[ 本帖最后由 yulihua49 于 2011-9-13 18:00 编辑 ]

newkid

"DAU那点东西一点没省，为了帮你解析json参数，还增加了一段。"
谁说没省？你不用读模版了，不用读字典了，不用生成SQL/绑定变量了，这一大堆不是省下来的？
至于那些格式解析、打包等东西，我同意转移到外面来。

"你看我的代码：有关于裸数据的处理。我试图把存储过程改成裸数据，没整明白，改不了。"
我找来找去只在这里见到一个：
http://ellebaek.wordpress.com/20 ... g-plsql-java-and-c/

Here's the implementation of the C external procedure (refcurdesc.c):
.......

他说这个C外部过程用OCI解析REF CURSOR, 你看看是不是。


"我很奇怪，这里的人都搞些什么应用？光用存储过程就行了？"
光用存储过程的应该也不多，但是学会PLSQL肯定是有用的。


"代码不好读？脑袋里不要老想着SQL，你要读的是业务逻辑。读到调用DAO时，哦，这个DAU取得了它的数据。不要想怎么取。这样一个业务逻辑的大脉络就清晰了。"
对我来说SQL就是业务逻辑的一部分，“取得数据的方法”是重要的一环，这里没写好就会影响整个事务的性能。
就是用PLSQL写存储过程，也有人主张用你的方法，把数据存取分离出来，变成子过程，业务逻辑层不写SQL, 而是调用子过程。我也不是反对这种做法，假如分离出去的部分可以重用、可以改善可读性，也未尝不可。注意前面的两个前提。


"具体如何取得数据，单看DAO程序，你可以看到WHERE条件，这一般就够了。干嘛还非要看有哪些列呢？要看列，就看模板。这好像没什么难度。
即使你的程序罗列了列名，一般我也是不看的（好多人喜欢select *)，只看WHERE。"
对我来说，取得哪些列也是重要一环。要修改表结构的时候，如果有这些静态SQL, 你可以快速知道哪些程序会受影响。

"看来大家对这个工作乐此不疲，那就不用模板也罢。"
我对PLSQL里面写SQL乐此不疲，我用静态SQL从来不需要PARSE,BIND,FETCH,CLOSE。

"我觉得有些人似乎是SQL依赖症。"
我很荣幸地对号入座。

"有说DAU程序不好懂的，看看这个，提意见。"

我还真的硬着头皮读了#150的程序。结论：不敢恭维。
insert_DAO最后一个参数stmt干什么用？看样子不像是往里传数据，因为OAD_exec没有用到它；反而出错的时候被改写(*stmt=0),但是只在update_by_PK使用，又不会返回任何数据给调用者？

（我又读了程序发现这个源头来自loadfile的参数buf,难道你是为了避免重复分配内存？那也应该有别的方法吧，何苦把程序接口弄得这么复杂？）

你既然有oad参数，数组长度应该不难得到，为什么还要设计第二个参数n?

num=_DAU.srm.tp[_DAU.srm.Aflg].offset; ------- 这个我说是天书有谁能反对？

再看你读文件的循环：
if(feof(ifd)) break;
这里不要急着出去嘛，先把“零头”处理了再退出，外面也少一段程序。

//返回后，还会有一个 ___SQL_Transaction__(SQL_Connect,TRANCOMMIT);
这个有点搞，你循环里面都提交了，为什么做完反而不提交，而要留给后面的代码？

[ 本帖最后由 newkid 于 2011-9-14 01:57 编辑 ]

yulihua49

昨天写了一大堆，都没了。