ORACLE傻瓜手册长篇连载
6 数据库优化所有参见内容都在附件05_optimize下。
一个以数据库为核心的应用系统，其80%以上的效率决定于应用软件架构是否合理、简洁、高效，支撑软件和硬件终究是放在第二位考虑的问题，这是系统分析员和程序员们的价值所在和使命所系。
6.1 通用设置
对于每个数据库系统，以下设置是固定的，企图在此仅通过某种设置优化实现神奇的效果，不是解决问题的正确途径，效果极为有限。
6.1.1 硬件配置
I/0负载均衡
按照一般要求，在没有RAID的情况下，将I/O频繁的数据文件分配在不同磁盘上，使磁盘负载均衡。
临时表空间、回滚表空间、在线日志的I/O操作都比较密集，同时应用数据对象在表空间上的分布也决定I/O操作的分布。
RAID
关于RAID 5的写效率一直存在争论，在实际应用中表现并不突出。如果有条件，可使用RAID 0+1。RAID 5适用于磁盘空间有限，又要求保证一定容错功能的中小型应用。
增加RAID卡缓存，并将Cache选项置为WriteBack而非WriteThrough。此两项对系统I/0影响之大，令人印象极其深刻。
6.1.2 应用配置
表与索引分在不同表空间中，分配适宜的数据块尺寸
为表和索引建立不同的表空间，并在创建表空间时指定于此建立的表或索引的缺省存储参数，这样此表空间上的所有对象使用统一的数据块尺寸、扩展率和最大可用数据块数量等参数，简化了配置过程，减少了存储空间的碎片
根据应用确定索引
检查应用程序SQL语句，尽可能在where的查询条件中使用整个索引，如不能满足，至少用到索引首列。
如在emp中建立索引：create index emp_x01 on emp(name,age)。
如果查询条件包含索引首列name：
select salary from emp where name like ‘Tom%’
这样的查询能够利用索引emp_x01。
如果查询条件不包含索引首列name，即使使用了索引的某个域，也不能利用到索引emp_x01:
select salary form emp where age=25;
索引首列的选择应综合考虑查询条件的组合情况，同时为使索引B+树尽可能产生多的分叉，应使用值变化较多的域，否则可考虑建立位图索引（bitmap index）
查询条件中对列的函数运算，列与列之间的比较会使执行效率大大降低，原因还是在于不能充分利用索引：
select salary from emp where substr(name,2,1)=’o’; #名字第二个字母是’o’
慎用order by，group by，它们会选出所有符合条件的记录，在temp表空间上进行处理，再输出。
评估应用程序中SQL语句的合理性
explain可以获得SQL语句的执行策略，从而提供改进的思路，但由于执行环境的不同而无法准确推断执行效率。
执行$ORACLE_HOME/rdbms/admin/utlxplan.sql建立plan_table
SQL>;explain plan select salary from emp where age>;25；
SQL>;start $ORACLE_HOME/rdbms/admin/utlxpls.sql或utlxplp.sql
查看分析结果，主要看是否出现表扫描、涉及的记录条数和耗费时间
6.1.3 日常性能监控
utlbstat和utlestat
编写以下两个脚本：
run_utlbstat.sh
sqlplus “/ as sysdba” << EOF
@${ORACLE_HOME}/rdbms/admin/utlbstat.sql
exit
EOF
run_utlestat.sh
cd /export/oracle/tuning_report
sqlplus “/ as sysdba” << EOF
@$ORACLE_HOME/rdbms/admin/utlestat.sql
exit
EOF
选择适当时间，如4:00运行run_utlbstat.sh，22:00运行run_utlestat.sh，可通过crontab方式执行。在/export/oracle/tuning_report下生成report.txt，并分析：
stats$lib PINHITRATIO应高
stats$waitstat 如undo header较高，则应加入更多回滚空间
如segment header较高，则应加入更多freelist(待查)
stats$roll 如TRANS_TBL_WAITS较高，则应加入更多回滚空间
stats$dc GET_MISS, SCAN_MISS应较低
stats$files I/O应平均分布于各磁盘
READS和BLKS_READ相差较大表明表扫描，相差较小表明index充分被利用 6.2 实战分析
当应用系统出现联机处理或批处理程序执行时间变长、反应缓慢的现象，就应该积极寻找减少消耗增加效率的方法。硬件升级是最后的终极的手段，也是最不能体现人的能力的手段，矛盾的暂时平息不意味未来不会再次爆发。
6.2.1 总体分析
分析一个高负荷、低效率的数据库系统先从分析操作系统的表现开始。
cpu利用率
使用sar 2 10发现：
a) %wio保持在50以上，%usr和%sys数值偏低
b) 或者%usr异常高，保持80以上，%wio几乎为0
而%idle总是接近0。
情形a）说明数据的检索量极大，无法从缓冲区中及时得到，oracle系统进程被迫从数据文件上将数据读入缓冲区替换掉一些陈旧的数据，从而使oracle服务进程处于等待状态。这是缓冲区不足的表现，可以通过适当增加缓冲区大小来缓解矛盾，但不能根本上解决问题，首先内存区域有限，不可能一直增加下去；其次即使缓冲区足够容纳下所需数据，矛盾会向b）转化。
情形b）说明oracle服务进程已能从缓冲区中得到几乎所有需要的数据，但由于冗余数据多，分析时间非常漫长，使cpu计算能力过多地被分配到oracle服务进程上。
两者的发生多为检索策略失当，特别在对索引的设计和利用上，从而导致表扫描。
必须结合应用程序的设计来进行改进，仅在数据库层面上很难有所作为。
曾经发生过一种情形类似a），只是%wio不算太高，而%idle很高。无法用常理分析，后更换存储设备后解决，推测是存储设备的问题。
内存和交换空间
每个oracle服务进程大约占用5M左右内存（mem），内存不足时，容易引起物理页的频繁换入换出，使系统I/O活动增加；还会占用20M左右交换空间（swap），当交换空间不足时，就不能增加新的oracle连接。
vmstat 2 10观察内存和交换空间的空闲情况，注意pi（kilobytes page in），po(kilobytes page out)，结合sar –d 2 10观察磁盘的繁忙程度，及时调整硬件。
top也能对内存和交换空间进行监控。
改进措施无非就是增加内存和交换空间，以及控制oracle服务进程的数目。
联机日志
sar –d 2 10观察磁盘I/0，注意read和write的比例
如write比例过高，打开$ORACLE_BASE/admin/oradb/bdump/alert.log，检查日志文件切换间隔，如小于15分钟，说明日志文件太小，导致切换频率过高，引起缓冲区和数据文件的同步（checkpoint）发生过于频繁。也可能由于数据库同步写进程（db_writer_processes）数量太少。
改进措施是创建新的日志文件组，适当扩大日志文件的尺寸，使同步间隔保持在30分钟以上为宜。
参见《配置》中的log_checkpoint_interval和db_writer_processes，作综合考虑。
6.2.2 详细分析
排除了上述效率问题，就要开始对数据库本身进行考察。
6.2.2.1 察看session当前执行的SQL语句
使用top观察oracle服务进程cpu占用情况，通常情况下单个进程不应超过5%，如果超过10%，一定发生了严重的检索策略失当
在此情况下，可认为有问题的oracle服务进程代表的session当前执行的SQL语句耗费了大量的时间，通过分析此SQL语句，能获得改进效率的线索
记录下待分析的oracle服务进程的进程号PID
获得oracle服务进程的session id，对应的应用进程信息，如进程号、主机名、程序名，以及正执行的SQL语句在缓冲池中的编号
sqlplus “/ as sysdba”
SQL>;select s.sid,s.serial#,s.process,s.machine,s.program,s.sql_hash_value from v$session s, v$process p where p.spid=’PID’ and s.paddr=p.addr;
获得正执行的SQL语句的文本
SQL>;select q.sql_text from v$session s, v$process p,v$sqlarea q where p.spid=’PID’ and s.paddr=p.addr and s.sql_hash_value=q.hash_value;
这个方法显示此oracle服务进程的会话当前使用的sql命令，并不一定是导致效率低下的sql命令，但低效率的命令往往在会话中停留较长的时间，所以大部分情况还是能够找出来的。 6.2.2.2 某段间隔session SQL语句执行情况
接上节，为更精确地分析此session中SQL语句的执行情况，需要获得某段间隔各SQL语句所占的比重，从而可以针对耗时较长的语句进行改进
记录下待分析的oracle服务进程的进程号PID
sqlplus “/ as sysdba”
SQL>;select s.sid, s.serial# from v$session s, v$process p where p.spid=’PID’ and s.paddr=p.addr;
SQL>;alter system set timed_statistics=true;
SQL>;execute dbms_system.set_sql_trace_in_session(sid,serial#, TRUE);
或execute dbms_session.set_sql_trace(TRUE)或alter session set sql_trace=true #对当前session做trace分析，分析文件生成于initoradb.ora中user_dump_dest指定的目录下
一段时间后……
SQL>;alter system set timed_statistics=false;
SQL>; execute dbms_system.set_sql_trace_in_session(sid, serial#, FALSE);
利用工具tkprof将report.trc文件转化为可读形式
tkprof report.trc report.txt sort=EXECPU explain=system/manager ＃选择CPU占用时间进行排序
举例：
call count cpu elapsed
parse 5 0.15 2.08
execute 12 6.30 41.04
fetch 0 0.00 0.00
update work_user_skill set work_level=:b0,skill_value=:b1 where (mb_loginname=:b2 and work_type=:b3) ＃mb_loginname和work_type恰好为主键
Rows Execution Plan
------- ---------------------------------------------------
0 UPDATE STATEMENT GOAL: CHOOSE
0 UPDATE OF ‘WORK_USER_SKILL’
0 TABLE ACCESS GOAL: ANALYZED (FULL) OF ‘WORK_USER_SKILL’
分析：
cpu与elapse相差很大说明I/O繁忙，请求等待时间长，有可能进行了表扫描
TABLE ACCESS出现FULL，即表扫描，说明：
可能一：未使用index。
可能二：使用了index，而未用首列。
可能三：使用了index，而由于其检索信息（主要是B+树）过于陈旧，使oracle在决定检索策略时，错误地选择了表扫描。
解决：
对策一：根据应用的实际需要酌情建立索引。
对策二：修改查询条件，或者修改索引的组成域和顺序，确保索引首列被使用。
对策三：更新相关索引的陈旧检索信息
sqlplus dbuser/oracle
SQL>;analyze index emp_x01 validate structure;
或者简单些
SQL>;analyze table emp validate structure cascade; #不仅重新检查了table的存储情况，还更新了它的所有index的检索信息
另外可重新组织index
SQL>;alter index emp_x01 rebuild [online]; #建议使用online选项，可以与更新此索引的其它操作同时进行 参考命令：
生成table的统计信息至dba_tables,user_tables
analyze table emp compute|estimate statistics for table [ all columns | columns col1,col2 | all indexed columns ]
生成index的统计信息至dba_indexes,user_indexes
analyze index emp_x01 compute|estimate statistics
6.2.2.3 检查被锁的对象
由于某种原因操作的对象被加锁，而又不能在短时间内解锁，会在此对象上形成sql操作等待队列，导致部分操作不得不超时退出，系统效率下降到难以接受的程度。这种现象可能是死锁，也可能因为某些事务耗时太长，影响操作同一对象的短事务。通常是应用程序组织不当的结果。
检查被长时间锁的对象：
sqlplus “/ as sysdba”
SQL>;select a.session_id,a.process,a.locked_mode,b.object_name,b.object_type,b.status from v$locked_object a,dba_objects b where a.object_id=b.object_id;
6.3 专题分析
6.3.1 巨表查询
参见hugh,脚本都在script下，程序都在program下。。
问题的提出
在数据库应用的开发中常常需要记录用户历史、流水等这样的数据，开发者的一般思路是仅建立一张表，以一个不重复的递增的序列号作为主键，配合查询的需要建立若干索引。
然而在数据条数积累到相当多的时候，比如几千万这样的级别，查询的效率问题就会成为令人头痛的瓶颈，因为查询凭借的索引本身也达到了相当复杂庞大的程度，任何一次查询都会带来很高的开销。由此还给批处理、数据备份、数据清理带来相当大的困扰。
尽管数据库系统在提高查询效率上已经提供了相当强劲的功能，但单纯依赖数据库往往不能应对复杂多变的现实情况。不得不采用一些专用设计，但需要跟通用做法进行权衡。
试图寻找解决巨表查询的方法，同时考虑巨表备份、清理。为形象地说明，建立user_log表，这张表储存典型的用户历史，包括序列号、日期、用户名、历史信息等。
步骤：
在某数据库实例中建立用户dbuser，口令为oracle
进入script目录
根据create_tablespace.sql建立各表空间
根据create_table.sql建立表和索引
运行genlog生成测试用数据
运行loadlog将数据上载到数据库中
进入program目录
运行make
数据组织方面，设想有一万个用户访问，每天留下20万条记录，延续15天，总共300万条记录，平均每人300条，每天20条，访问的数据随机生成
硬件设备为PIII800EB+512M+Quantum FireBall 10代
分割建表
由于user_log中log_dt（记录日期）是一个划分数据范围的天然标志，所以很自然地想到把日期作为表名的一部分，从而将巨大的表分割成较小的表，期望从较小的表和索引中获得较高的查询效率。能否实现这个想法？于是有以下测试。
program目录下有user_log_static.c和user_log_dyna.c，前者对整个user_log查询，后者对已分割成user_log_yyyymmdd的表查询，随机生成某个用户名，选出在log中这个用户的全部记录，共100次。运行7次，前2-3次由于数据缓冲的原因与后面的相差较大，可以忽略掉。
选出全部记录 （以秒为单位）
未分割 198 122 118 71 53 46 46
分割 255 129 79 58 50 48 48 从结果上看，分割几乎没有任何效果。根据理论分析，表分割后，应用不得不使用动态SQL对每张表分别操作，原先的一次查询被分成多次串行，尽管每次查询的数据量大为减少，但叠加上去也很可观。查询的日期范围越大，叠加的效应越强。所以在这种情况下，分割表的做法不能带来效率上的提高，甚至可能更糟。
但在通常的应用中，不需要一下子选出全部的查询所得，更多的是分批提供，比如显示用户历史记录，一屏可能就只有10条，向前或向后翻页时再次向服务器提交请求。试想在分割表的情况下，有可能在取到足够记录时，只需要查询数目很少的表，这样效率提高就很明显。修改user_log_static.c和user_log_dyna.c，将Process函数中关于变量count的两行注释去掉，只选出100条记录就中止查询，大致估计访问5张分割表。
100条记录 （以秒为单位）
未分割 221 111 58 41 41 36 35
分割 96 51 30 25 18 15 14
可以作出这样的结论：只要将访问的表的数目控制在较小的范围，分割表的查询效率就能得到明显的提升。
分区建表
在oracle8中可以使用partition选项将表或索引存放在不同的区域中，这样的做法与上面的分割表方法似乎是殊途同归。
program目录下有user_log_partition.c，对user_log_partition进行查询，user_log_partition的数据域和user_log完全一致，数据也是使用同样的规则随产生，可以认为user_log_partition比起user_log差别仅在于partition选项。
索引的分区是否能带来性能上的提升？先测试数据、查询使用的索引都分区配置的情况，第一行选出全部记录，第二行选出100条记录
（以秒为单位）
全部 236 121 73 48 46 42 40
100条 47 45 44 40 38 38 37
数据分区配置，而查询使用的索引非分区配置，第一行选出全部记录，第二行选出100条记录
（以秒为单位）
全部 238 120 69 48 45 42 41
100条 37 37 39 37 35 35 33
无论数据还是索引使用或不使用分区，都没能带来预期中的效率提升，也许是测试案例不够全面，测试用机器不够专业的原因吧。
总结
应用层次上的表分割，还是数据库层次上的表分区，是值得考虑的选择。前者以缩小单张表的规模为目标，企图在较小的数据范围内以较高的效率完成工作，同时数据备份、清理也能以表为单位进行处理，代价是应用必须围绕着设计调整，通用化的程度弱，编程方面考虑得多，特别在应用某些成型软件时，几乎不能作这样的调整。而表分区能在不改动应用的前提下，透明地提高查询效率（见Oracle文档，尽管在本次有限测试中未能体现），缺点在于配置过于繁琐，数据库管理员需要对应用的非常了解，根本上讲只是在巨表内部作了有限的优化。
6.3.2 对比测试
参见benchmark,脚本都在script下，程序都在program下。
这组测试的目的是为了搞清楚对表的不同处理方式会导致效率上怎样的差异，同时希望以数字代替长久以来的猜测。
结合笔者曾经参与过的一个项目，为测试设立了3张表，参见script/create_table.sql：
charge_fee：费用
charge_fee_dtl：费用明细
charge_fee_cfg：费用配置
charge_fee模拟了某种费用，如水、电、煤、电话等每月的缴付记录，包括缴费状态、费用月份、用户名、缴费日期等信息。生成1,000,000条记录，分布在10,000个用户名上，平均每个用户100条记录。
charge_fee_dtl进一步说明某笔费用的具体情况，如电话费常常细分为固定费用、市话、长话、漫游、国际等。对应charge_fee，每条费用记录拥有5个分项（假定用户不会在每个分项上都产生费用，所以从10个分项中随机选择了5个），共有5,000,000条记录。它采用charge_fee的序列号，也就是主键，作为分项和费用多对一关系的凭据。
charge_fee_cfg对charge_fee_dtl中每个分项进行文字说明，是一张配置表，共有10条记录，代表10个分项。
这3张表大致反映了大（charge_fee）－大（charge_fee_dtl）－小（charge_fee_cfg）的模式，下面分析在它们上面使用嵌入式SQL进行查询的效率。
测试服务器硬件配置：PII400，512M SDRAM，昆腾火球10代10G。
软件配置：Solaris 8 Intel Platform Edition 10/01，Oracle 8iR3
Join vs Not Join
在开发程序的时候，表与表间的连接是经常的选择，这样做可以很简洁地写出代码。然而，将涉及的表连接起来和顺序选出之间的效率差异，哪些场合可以使用或者不适合使用连接，等等诸如此类的问题往往容易为开发者忽略。
大（charge_fee）－大（charge_fee_dtl）连接：
模拟需求：选取某个用户的费用记录，并选出每笔费用的分项记录（常用于查询、缴纳费用的场合）。
这个需求将2张记录都很多的表charge_fee和charg_fee_dtl联系起来，以比较采用连接与否的效率差异。
引入程序bb_join.c和bb_nojoin.c（bb—big table & big table），前者使用一个连接2张表的游标，直接选出费用和分项记录，后者仅使用对charge_fee的游标，选出费用记录后，再根据费用序列号，从charge_fee_dtl中选出分项记录。两者都使用了order by选项。
为更好地显示查询效果，每次程序运行随机选取100个用户，记录总耗时。同种测试进行7次。
上面说过平均每个用户拥有100条费用记录，而每条费用记录拥有5个分项。
测试一：选出用户全部100条费用记录
（以秒为单位）
连接（bb_join） 96 78 77 76 77 76 77
不连接（bb_nojoin） 92 96 93 97 95 95 95
结果有点出乎笔者的意料，因为笔者长久以来认为2张记录都很多的表的连接会带来很大的系统开销，然而事实证明，连接和不连接（顺序查询）的效率近似，而且连接的表现更好一些！
联系到上一节《巨表查询》的结果，笔者很快就想到：不连接方式由于对每笔费用记录（charge_fee）都要重新展开一个对分项记录（charge_fee_dtl）的游标，总计大约100（每个用户费用记录条数）*100（用户数）=10,000次之多，耗费很大，而实际应用中很难有一次选出某用户上百条记录的情况，如果减少一点，比如每个用户只选出20条，游标开启次数降为约2,000次，结果会怎样？
基于这个想法，在2个程序中加进了对费用记录条数的控制，见注释部分。
测试二：选出用户前20条费用记录
（以秒为单位）
连接（bb_join） 82 75 67 67 66 68 72
不连接（bb_nojoin） 24 17 13 10 9 8 8
结果同样令笔者吃惊！性能提高得很明显，由此可以得出与《巨表查询》相似的结论：在涉及2张记录都很多的表操作中，如果采用不连接的方式，只要将顺序完成的查询控制在一定数量内，一定能取得比连接方式高的效率。 大（charge_fee_dtl）－小（charge_fee_cfg）连接：
模拟需求：选取某笔费用的分项记录，并显示每笔分项的文字说明（常用于打印单据的场合）。
这个需求将1张记录都很多的表charge_fee_dtl和另1张记录极少的表charg_fee_cfg联系起来，以比较采用连接与否的效率差异。
引入程序bs_join.c和bs_nojoin.c（bs—big table & small table），前者使用一个连接2张表的游标，直接选出分项和配置记录，后者事先将charge_fee_cfg全部读取到内存中，仅使用对charge_fee_dtl的游标，选出分项记录后，再根据分项类型，从内存中选出分项的文字说明。两者都使用了order by选项。
为更好地显示查询效果，每次程序运行随机选取30,000笔费用记录，记录总耗时。同种测试进行7次。
（以秒为单位）
连接（bs_join） 77 75 76 74 76 74 75
不连接（bs_nojoin） 67 66 66 65 67 65 66
结果差不多，可以得出结论：在涉及1张记录很多的表和另1张记录很少的表操作中，采用连接与否，效率相差不大。从灵活的角度考虑，建议对记录很少的表（往往是静态配置）多利用内存缓冲。
Static vs Dynamic
这里比较静态嵌入式SQL和动态嵌入式SQL语句的效率差异，动态方式多了一个对SQL语句的prepare过程。
引入程序bs_nojoin_dyna.c，其实就在bs_nojoin.c的基础上，把静态嵌入式SQL语句的部分代码改成动态嵌入式SQL语句。
（以秒为单位）
静态（bs_nojoin） 67 66 66 65 67 65 66
动态（bs_nojoin_dyna） 97 96 95 96 94 95 95
动态方法比起静态方法效率上有一定的差距，但如果考虑到动态方法的灵活性，笔者认为可以接受。
Local vs LAN
实际应用中经常把数据库和应用程序安装在独立的服务器上，这样应用进程调用数据库接口时，会受到一些因素的影响，如网络接口系统调用开销、操作系统内核对发起网络请求进程的调度、网络传输延迟等等，效率下降是不可避免的，下面对这样的效率损失作一个有趣的统计。
将程序bs_nojoin.c移到另一服务器上，以此服务器为客户机，数据库所在服务器为服务机。
客户机配置：PIII Xeon 550，1G SDRAM，IBM DNES-318350Y硬盘，服务机维持不变。网络为10M以太网。
（以秒为单位）
本地（bs_nojoin） 67 66 66 65 67 65 66
局域网（bs_nojoin） 171 165 165 165 166 165 165
效率差距令人震惊！由于条件限制，没有对100M以太网的情况进行测试，相信会有较大的改善。
结论：尽可能本地访问数据库，如果必须跨机访问，应使用高速局域网。 6.3.3 上下载数据
参见upload_download。
一直认为把数据从数据库里倒进倒出是一件体力活，仅仅是利用一些数据库工具的简单任务。然而在经历了无数个不眠之夜后，渐渐体会到，这个简单任务居然已经成为DBA的一项主要工作，而且是直接关系到DBA身心健康的大问题。所以觉得有必要对此作一点研究了。
测试服务器硬件配置：PIII800EB，512M SDRAM，Maxtor DiamondMax VL 40 33073H3 30G硬盘。
软件配置：RedHat Linux 7.3，Oracle 9iR2
参见create_tablespace.sql和create_table.sql，建立测试所需表空间和表。
表user_info模仿了某种用户信息记录，建立一些索引方便查询。建表语句没有包括primary key关键字，具体原因到讨论imp时会提到。
上载文本--sqlldr
关于下载文本，在《工具》中的sqlplus里已经介绍过了，而且基本上没有提高效率的方法，因此不作深入。
首先产生3,000,000条记录，运行genrec，本目录下生成ctl目录，里面有一个叫user_info.ctl的文件，即为sqlldr的控制文件，数据都在此文件中，具体选项参见《工具》中的sqlldr。运行loadrec进行测试。
测试一：不使用任何参数
sqlldr dbuser/oracle control= ctl/user_info.ctl log=ctl/user_info.log
缺省情况下，sqlldr采用常规路径（conventional path）方式上载，rows=64，bindsize=65535
耗时：41:07
测试二：常规路径（conventional path）方式，采用较大的缓冲参数
sqlldr dbuser/oracle control=ctl/user_info.ctl log=ctl/user_info.log rows=10000 bindsize=8192000
参见loadrec中的conventional path
耗时：24:31
测试三：直通路径（direct path）方式
sqlldr dbuser/oracle control=ctl/user_info.ctl log=ctl/user_info.log direct=y
参见loadrec中的direct path
耗时：6:15
由此可见直通方式能够大幅度提高上载效率。
测试四：直通路径（direct path）方式，关闭表和索引logging
因为数据插入会记录日志，如果关闭表和索引的logging选项，应该可以进一步提高上载效率。
对于常规路径方式，无论logging选项是否关闭，都会记录日志，所以在测试一和测试二中没有调整logging选项。
对表和索引使用alter table|index … nologging命令。
sqlldr dbuser/oracle control=ctl/user_info.ctl log=ctl/user_info.log direct=y
参见loadrec中的direct path
耗时：3:25
结论：使用直通方式上载，并关闭相关表和索引的logging选项。
注意：采用直通方式，如果被操作的表的索引上载前已被建立，在上载过程中不对索引进行操作，待数据全部进入后，再执行更新索引的操作，奇怪的是，进行此操作时数据库使用的是回滚空间，所以应注意回滚空间的大小。
曾尝试过使用不同大小的日志文件，以求降低检查点（checkpoint）发生的频率，但几乎没有产生任何效果。
导出dmp文件--exp
假定表user_info中已有了3,000,000条记录。
运行exprec进行测试，在本目录下新建dmp目录，在此目录下产生user_info.dmp文件。 测试一：常规路径（conventional path）方式
exp dbuser/oracle file=dmp/user_info.dmp log=dmp/user_info.log tables=user_info buffer=4096000 feedback=10000
参见exprec中的conventional path
耗时：2:17
测试二：直通路径（direct path）方式
exp dbuser/oracle file=dmp/user_info.dmp log=dmp/user_info.log tables=user_info direct=y feedback=10000
参见exprec中的direct path
耗时：1:37
结论：使用直通方式导出dmp文件。
导入dmp文件--imp
利用已经导出的user_info.dmp。
运行imprec进行测试。
测试一：不作任何调整
imp dbuser/oracle file=dmp/user_info.dmp tables=user_info fromuser=dbuser touser=dbuser buffer=4096000 commit=y ignore=y feedback=10000
参见imprec中的index
耗时：19:29
联系sqlldr的表现，很自然地想到将表和索引的logging选项关闭，然而imp没有直通方式！因此logging选项在此无所作为。
在导入过程中imp缺省更新索引，当数据导入量逐渐增大，对索引的更新是一个逐渐变慢的过程，所以一个很自然的想法是：先导入数据，再建立索引。可以设置选项indexes=n使imp在导入数据同时不进行更新索引的操作，然而如果导入前索引已被建立，此选项无效（参见《工具》中的imp），因此必须在导入前：1.先建立表（imp会缺省建表和索引）2.确保所有的索引没有建立。这也是建表脚本不使用primary key的原因：primary key会建立unique index，而且不能去除，就primary key的功能而言，代之以unique index没有问题。
测试二：使用indexes=n，先不建立任何索引，导入结束后，再建立索引
参见imprec中的no index
imp dbuser/oracle file=dmp/user_info.dmp tables=user_info fromuser=dbuser touser=dbuser buffer=4096000 indexes=n commit=y ignore=y feedback=10000
耗时：7:55
SQL>;create unique index user_info_x00 on user_info(loginname) tablespace tbsindex;
SQL>;create unique index user_info_x01 on user_info(nickname) tablespace tbsindex;
SQL>;create index user_info_x02 on user_info(register_dt) tablespace tbsindex;
耗时：2:20
总耗时：10:15
结论：先建表，不建索引，使用不更新索引的导入方式，最后统一建立索引。
先导入数据还有一个额外的好处：数据尽早安全地进库，无论对DBA还是项目的其他成员心理上都是一个极大的安慰，反正有了数据就有了一切，至于后面的建立索引，相对从容许多了，即使时间拖得长一些，关系也不大。这是笔者多次倒数据的切身体会。
6.3.4 回滚空间快照陈旧（snapshot too old）
有这样的两种情况：
1. 根据某些条件选取一批记录，在游标不关闭的情况下，作一定处理，再更新回去
2. 根据某些条件选取一批记录，输出到某地。
这是再平常不过的操作。但如果这个选取过程变得比较漫长，往往在某个时刻的fetch会返回snapshot too old错误，导致选取过程中断。尤其是第一种情况，发生错误的概率很大。
这是Oracle特有的现象，跟它对回滚空间的利用策略有关。
Oracle自动使用语句级别的读取一致性策略，保证返回的数据都是查询发起时刻的模样，对查询过程中结果集发生的变动不加理会。
为了达到这个目的，Oracle使用回滚空间中维持的信息结合数据文件提供一致性视图，回滚空间包含已被未提交或已提交事务修改过的数据的原值。
Oracle使用System Change Number(SCN)区分时刻。当查询语句进入查询阶段以后，系统分配一个SCN，产生结果集后，对应到数据文件，只有SCN比查询SCN旧的数据块才会被读取，如果在查询过程中某数据块被更新，即SCN被改变，比查询SCN新，这样必须检索回滚空间，重建旧数据块的内容。 如果回滚空间中相应的内容被覆盖，Oracle就认为旧数据块过于陈旧，无法重建出来，这就是snapshot too old的由来。针对这种错误，Oracle建议使用更大的回滚空间，这是有道理的，但更大的回滚空间仍有不敷使用的时候，不足以应付多变的应用，只能算一种消极应付的对策。
第一种情况：
假定不能重建的数据块为X，当X中的记录被更新（无论来自于本次游标操作，还是其它数据库连接，更多可能是来自于自身），SCN同时刷新，如果经过某段间隔再要读取X中记录就必须根据回滚空间相关内容重建旧X，而一旦这段间隔中发生较多的数据库更新操作，回滚空间有可能在消耗完空闲内容后被迫覆盖旧内容，这样X的重建就无法完成。
比较好的解决方法是：游标展开后将记录主键和更新所需用到的域读至内存，不执行更新操作，随即关闭游标，再处理这些记录，根据主键分批更新回数据库。
第二种情况：
与第一种情况类似，只不过更新操作全部来自于其它数据库连接。
没有太好的解决方法，尽量加快查询过程，保证其它连接不发生或少发生与本次查询相关的更新操作。 7 常用技巧
所有参见内容都在附件07_skill/下。
7.1 增加、更改和删除域
增加域
SQL>;alter table emp add(column_x char(10) not null);
域被增加到表结构的末尾。
更改域
SQL>;alter table emp modify(column_x char (20));
对于char类型的域，只能扩展，不能缩小；char与varchar2可互为转换。
删除域
如待删除域属于某个索引，则不允许删除操作，必须将此域先设置为NULL。
SQL>;alter table emp modify(column_x null);
SQL>;update emp set column_x=null;
SQL>;commit;
SQL>;alter table emp drop(column_x);
在原表基础上改动结构有一定的局限性，比如“增加域”，新域只能添加到表结构的末尾，破坏了原有的整齐和协调。建议采用这样的方法：新建表，再将原表数据迁移过去，最后去除旧表。
假设要在表dbuser.emp中增加域colx,(col1,col2,col3)(col1,col2,colx,col3)
修改emp.sql
sqlplus dbuser/oracle
SQL>;alter table emp rename to emp_temp; ＃原表改名
SQL>;start emp ＃建立新表
编辑SQL脚本modi.sql
insert into emp(select col1,col2,’ ‘,col3 from emp_temp where …);
sqlplus system/system
SQL>;alter rollback segment r99 online; ＃见“调整rbs表空间”中关于r99的设置，Oracle 9i中不需要
SQL>;connect dbuser
SQL>;set transaction use rollback segment r99; ＃见“调整rbs表空间”中关于r99的设置，Oracle 9i中不需要
SQL>;start modi; ＃迁移数据
SQL>;commit;
SQL>;connect system
SQL>;alter rollback segment r99 offline; ＃见“调整rbs表空间”中关于r99的设置，Oracle 9i中不需要
SQL>;drop table emp_temp; ＃去除旧表
7.2 删除冗余记录
参见02/。
需求：user_log记录用户大量log，现在需要进行清理，只保留最新一条。
表结构：
create table user_log
(
log_sq number(12) not null,
user_nm char(20) not null,
user_log_tx varchar2(255) not null,
last_upd_ts date,
primary key (log_sq)
);
log_sq利用了sequence的值。
方法：
sqlplus –s dbuser/oracle <<EOF >;/dev/null
set heading off;
set term off;
set echo off;
set pagesize 0;
set linesize 1000;
set trimspool on;
set trimout on;
set feedback off;
set colsep |;
spool tmp.txt;
select user_nm,count(*),max(log_sq) from user_log group by user_nm having(count(*)>;1);
spool off;
exit
EOF
tr –d ‘ ‘ < tmp.txt | sed –e “s/^/’/
s/|/’|/1” | awk ‘BEGIN { FS=”|” } { printf(“delete from user_log where user_nm=%s and log_sq<%s;\n”, $1, $3); }’ >; del.sql
执行del.sql
注意：sed要用双引号，作用是为user_nm加上单引号，因为awk命令中的单引号会与其命令引用所用的单引号混淆，无法在awk命令行中为user_nm添加单引号，使用单独的awk脚本就没有这个问题
7.3 更改字符集
条件：新字符集必须为原字符集的超集，如USASCII7ZHS16GBK。ZHS16CGB231280并不是ZHS16GBK的子集
假设oradb原字符集为USASCII7，更改为ZHS16GBK
sqlplus “/ as sysdba”
SQL>;startup mount
SQL>;alter system enable restricted session;
SQL>;alter system set job_queue_processes=0;
SQL>;alter database open;
SQL>;alter database character set ZHS16GBK;
SQL>;shutdown
SQL>;startup 7.4 表数据迁移
需求：将一张表或几张表中的域重新组合后插入新表。
上面的“增加、更改、删除域”已经描述了一张表迁移到另一张表的情况，这里讨论多张表合并的情形。
假定原先的两张表为emp,work，现选择部分数据域合并为emp_work
对回滚段的操作不再重复叙述，Oracle 9i中不需要
建立emp_work
SQL>;insert into emp_new select a.no, sysdate, a.name, b.service_duration from emp a, work b where a.no=b.no;
SQL>;commit;
当连接涉及的数据量较大时，对临时段next扩展块大小有一定要求，参见《创建》中的“调整临时表空间”。
这样的方式仍然要使用回滚段，为加快数据迁移速度，可将insert替换成insert /*+APPEND*/（大小写不论），指示oracle以直通方式直接写数据文件，绕过回滚空间。
SQL>;insert /*+APPEND*/ into emp_new select a.no, sysdate, a.name, b.service_duration from emp a, work b where a.no=b.no;
SQL>;commit;
7.5 成批生成数据
参见05/。
笔者曾经为一个类似题库的项目做过数据上载，题目是选择题。需求非常简单，但对于DBA来说，此类的数据维护经常会碰到，所以在这里记录下来，仅仅是为了提供一种解决问题的思路。
由于题库的提供者对数据库一无所知，所以跟他们之间的数据文件接口使用了简单而通用的定义。这是一个文本文件，每道题目和答案占用一行，每个数据域以“|”分隔，为简单计，第一个答案为正确答案，例如：
GSM技术最初是哪个地区的标准？|欧洲|美国|中国|日本
对此接口文件要进行详细的描述，最好提供样例文件，非技术人员对“数据接口”这一概念感觉极为迟钝，如果不作硬性规定，他们会怎么方便怎么来，结果象word、excel、access等五花八门的文件都会出现，格式随心所欲，甚至还会口头通知。
下面的问题是将每行记录拆分到question和answer两张表中去，并在表question中记录正确的答案编号，而表answer中相对于某问题的数个答案编号必须是打乱的。这一任务交给awk完成。
打乱答案编号：
choice_qt=NF-1; #答案的数目
for(i=0; i<choice_qt; i++) aAnswer=0;
i=0;
while(i<choice_qt) #依次分配答案编号
{
ind=int(rand()*choice_qt); #随机取得答案下标，注意rand()的范围是[0,1)
if(aAnswer[ind]==0) #如果此下标代表的答案还没有被赋予编号，就将此编号赋予它；如果已有了编号，不作任何处理，再去随机选择答案下标。这种方法会浪费一些效率，但比较简单。
{
aAnswer[ind]=i+1; #编号实际从1开始
i++;
}
}
拆分成两张表：
printf("insert into question values(question_seq.nextval,'%s',%d);\n", $1,aAnswer[0]);
for(i=0; i<choice_qt; i++)
{
printf("insert into answer values(question_seq.currval,%d,'%s');\n", aAnswer,$(i+2));
} 7.6 注意要点
cursor
cusor for update不能嵌套使用，并且只能在一个transaction中完成
sequence
在同一session中，必须首先调用sequence.nextval，如先调用sequence.currval，oracle会认为使用了sequence未定义的值
有些场合往一张或多张表中插入记录时，需要使用相同的序列号，可先得到sequence.nextval，代入宿主结构，再对表操作
比如增加一条雇员工资记录（emp_salary_hist）及其明细（emp_salary_hist_dtl）
SQL>;select emp_salary_hist_sq.nextval from dual;
SQL>;insert into emp_salary_hist values(seq,…);
SQL>;insert into emp_salary_hist_dtl values(seq,…);
rownum
rownum<=N作为查询条件时，不能与order by,group by此类需将记录全部选出来的操作共用，因为rownum优先。
选择记录集中第N条记录时应参照以下做法：
如此记录集的查询SQL语句不含order by
select name from (select name, rownum rowseq from emp where age>;25) where rowseq=N;
如此记录集的查询SQL语句包含order by
select name from (select name,rownum rowseq from (select name from emp where age>;25 order by no)) where rowseq=N;
count
获取记录集条数时，count(1)最快，count(某列)得出的记录数目不包括此列中null值的数量 8 嵌入式SQL（C）
所有程序例子都在附件08_proc/下。
在C语言程序代码中直接嵌入SQL语句，使数据库编程变得非常简单明了，而且嵌入式SQL是一种标准，代码不需要很多的修改就能移植到支持嵌入式SQL的数据库系统上去，但这同时也是一个缺点，许多数据库系统不提供嵌入式SQL的预编译器。
8.1 编译
编译过程分为两步，第一步，对带有嵌入式SQL的C代码程序（通常此程序以.pc结尾，简称PC代码）使用proc做一次预编译，将里面的嵌入式SQL转化为代表数据库功能调用的C代码。第二步，使用C编译器将C代码编译连接成可执行文件。
配置文件
proc首先读取$ORACLE_HOME/precomp/pcscfg.cfg，里面的选项与命令行选项作用完全相同，这样可以让proc使用变得简洁。但从减少系统配置步骤、保持应用迁移的灵活性的角度出发，建议对此文件不作修改，将各种选项写在程序的编译文件中。
命令行选项：
sys_include：系统头文件目录，如/usr/include,/usr/lib/gcc-lib/i486-suse-linux/2.95.3/include,/usr/lib/gcc-lib/i386-redhat-linux/2.96/include ,$ORACLE_HOME/precomp/public,$(ORACLE_HOME)/rdbms/public -I$(ORACLE_HOME)/rdbms/demo，前3个通常在配置文件中已经写入
include：自定义的应用头文件目录
sqlcheck：SQL语句检查方式，语法（SYNTAX）和语义（SEMANTICS）。
语法：仅检查SQL语句的语法结构
语义：除语法检查外，还检验数据库对象和宿主变量的有效性
userid：访问数据库途径，在sqlcheck为语义检查时必须指定，如dbuser/oracle@oradb
iname：输入pc文件名
oname：输出c文件名
如果省略iname、oname，只需输入pc文件名，缺省转化成同名后缀为.c的C文件。
threads：线程支持，yes或no
例子
proc sqlcheck=semantic userid=dbuser/oracle threads=yes sys_include=$(ORACLE_HOME)/precomp/public sys_include=$(ORACLE_HOME)/rdbms/public sys_include=$(ORACLE_HOME)/rdbms/demo include=$IN threads=yes iname=emp.pc oname=emp.c //$IN是自定义的应用文件目录
gcc -I$(ORACLE_HOME)/precomp/public -I$(ORACLE_HOME)/rdbms/public -I$(ORACLE_HOME)/rdbms/demo –g –c –o emp.o emp.c
参见proc/single/Makefile。
8.2 SQL语句
建议设立一个与表结构一一对应的结构定义，作为宿主结构，下面的所有例子几乎都会用到关于表emp的宿主结构（emp_t emp）。
参见proc/single/db.h中emp_t和emp建表脚本proc/single/emp.sql。
8.2.1 内部类型与宿主类型对应
下面是最常用的内部数据类型和宿主变量类型的对应关系：
内部数据类型 宿主变量类型
char(n) char[n+1]
varchar2(n) char[n+1]
number(n<=6) int
number(n>;6) double
number(m,n) double
date char[15] 8.2.2 连接和断开
最简单的形式
这是最为常用的形式：应用程序不指明任何数据源，Oracle库从环境变量ORACLE_SID中得到数据库实例名，在本机连接此实例。应用程序只要输入数据库用户名和口令即可。
strcpy(dbuser,”dbuser”); strcpy(password,”oracle”);
EXEC SQL connect :dbuser identified by :password; //dbuser和password是char[n]的宿主变量。
也可以将用户名和口令写在一起。
strcpy(dbuser_password,”dbuser/oracle”);
EXEC SQL connect :dbuser_password;
跨机连接
首先在$ORACLE_HOME/network/admin/tnsnames.ora中添加对方数据库信息，取得一个连接名。
假定已经在tnsnames.ora中配好了名为oradb2的连接。
strcpy(dbstring, “oradb2”);
EXEC SQL connect :dbuser identified by :password using :dbstring;
多个连接
可以在一个应用程序中同时使用两个以上的数据库连接，为区分不同的连接，要为每个连接起一个名字。
strcpy(dbuser,”dbuser1”); strcpy(password,”oracle1”);
strcpy(dbconnect,”dbconnect1”);
EXEC SQL connect :dbuser identified by :password at :dbconnect;
strcpy(dbuser,”dbuser2”); strcpy(password,”oracle2”);
strcpy(dbconnect,”dbconnect2”);
EXEC SQL connect :dbuser identified by :password at :dbconnect;
在多连接的情况下，每句sql都要指明连接名。
EXEC SQL at :dbconnect select …; //下面不再讨论多连接，仅仅说明其使用方法
断开
应用程序无论正常还是非正常退出，数据库连接自动中断，也可以显式关闭。
EXEC SQL commit work release;
8.2.3 事务
提交
EXEC SQL commit;
回滚
EXEC SQL rollback;
8.2.4 标准SQL语句
select
EXEC SQL * into :emp from emp where no=:emp->;no;
EXEC SQL select name,to_char(upd_ts,’yyyymmddhh24miss’) into :emp->;name,:emp->;upd_ts from emp where no=:emp->;no;
lock
EXEC SQL select * into :emp from emp where no=:emp->;no for update;
update
EXEC SQL update emp set duty=:emp->;duty,upd_ts=sysdate where no=:emp->;no;
delete
EXEC SQL delete from emp where no=:emp->;no;
insert
EXEC SQL insert into emp values (:emp);
EXEC SQL insert into emp values (:emp->;name,:emp->; name,:emp->;age,:emp->;duty,:emp->;salary,:emp->;to_date(upd_ts,’yyyymmddhh24miss’));
cursor
EXEC SQL declare emp_cur cursor for select * from emp where age>;25;
EXEC SQL open emp_cur;
EXEC SQL fetch emp_cur into :emp;
EXEC SQL close emp_cur; 8.2.5 动态SQL语句
在输出域或输入查询条件，甚至表名，不能事先确定的时候，可以引入动态sql语句的方法。
非查询语句
专指insert,update,delete等无结果集的sql语句。
不带宿主变量：
最直接的做法，处理一条纯粹的sql语句，不需要任何变化，每次都完整地从sql解析走到执行。
strcpy(sql,”delete from emp where no=0”);
EXEC SQL execute immediate :sql;
查询条件使用宿主变量：
目的是为了只进行一次解析，以后只需绑定不同输入就能直接执行。
strcpy(sql,”delete from emp where no=:no”);
EXEC SQL prepare sql_stmt from :sql;
emp.no=0;
EXEC SQL execute sql_stmt using :emp.no;
emp.no=1;
EXEC SQL execute sql_stmt using :emp.no;
查询语句
查询必须使用游标方式。
strcpy(sql,”select * from emp where duty=:duty and age>;:age”);
strcpy(emp.duty,”1”); emp.age=20;
EXEC SQL prepare sql_stmt from :sql;
EXEC SQL declare sql_cur cursor for sql_stmt;
EXEC SQL open sql_cur using :emp.duty,:emp.age;
EXEC SQL fetch sql_cur into :emp;
EXEC SQL close sql_cur;
8.2.6 数组操作
利用宿主数组可以用一次sql操作处理成批记录，降低了应用程序与oracle服务进程之间的通讯开销，也减少了sql语句解析次数，这样能提高数据库应用程序的效率，对update,delete和insert尤为有效。
宿主数组
假定要操作表emp，定义宿主数组：
double a_no[50]
char a_name[50][21];
CURSOR
目的在于：试图在一次fetch中选出批量数据以减少fetch的次数。但fetch过程本身消耗资源不大，所以使用宿主数组对效率提高有限。
int rec_count; //本次条数
int accu_count; //累计条数
EXEC SQL declare emp_cur FOR select no,name from emp where age>;25;
EXEC SQL open emp_cur;
EXEC SQL fetch emp_cur into :a_no,:a_name; //rec_count保存当前fetch的记录条数，最多为a_no,a_name中较少的结构个数
rec_count=sqlca.sqlerr[2]-accu_account; //sqlca.sqlerr[2]记录cursor累积读取的记录条数，这样与上次累积数之差就是本次读取的条数
accu_count=sqlca.sqlerr[2]; // accu_count保存累积fetch的记录条数
当最后一次取完时，sqlca.sqlcode为1403，即记录不存在，注意count可能会大于0，这里的“记录不存在”只是表明“没有填满宿主结构”。
SELECT
EXEC SQL select no,name into :a_no,:a_name from emp where age>;25;
不能用for :rec_count子句进行操作记录条数控制，即不可指定选出若干条记录，因为有“执行此语句若干次”和“一次选出若干条记录”的歧义，需要条数控制应使用CURSOR。
DELETE
在a_no中准备N条待删除记录的no，也就是主键。
a_no[0]=0; a_no[1]=1; a_no[2]=2; …
rec_count=N;
EXEC SQL for :rec_count delete from emp where no=:a_no;
UPDATE
假定要更新一部分记录的name域。
在a_no中准备N条待更新记录的no，在a_name中准备N个新的name，两者必须一一对应。
a_no[0]=0; strcpy(a_name[0],”职员0”);
a_no[1]=1; strcpy(a_name[1],”职员1”);
…
a_no[N-1]=N-1; strcpy(a_name[N-1],”职员N-1”);
rec_count=N;
EXEC SQL for :rec_count update emp set name=:a_name where no=:a_no;
INSERT
为了说明问题，这里对emp表作了一些改变，假定除no和name域外都有缺省值。
在a_no,a_name中准备N条记录的no和name，两者必须一一对应。
a_no[0]=0; strcpy(a_name[0],”职员0”);
a_no[1]=1; strcpy(a_name[1],”职员1”);
…
a_no[N-1]=N-1; strcpy(a_name[N-1],”职员N-1”);
rec_count=N;
EXEC SQL for :rec_count insert into emp(no,name) values(:a_no,:a_name);
宿主结构数组
宿主结构数组其实是宿主变量组合起来的数组，由于update set语句的特殊性，所以宿主结构数组仅能用于SELECT,FETCH和INSERT
定义部分域结构组合emp_part_def a_emp_part[50]，和a_no[50]形成混合模式。
double a_no[50];
typedef struct
{
char name [21];
int age;
} emp_part_def;
emp_part_def a_emp_part[50];
SELECT
EXEC SQL select no,name,age into :a_no,:a_emp_part from emp where age>;25;
CURSOR
iAccuCount=0;
EXEC SQL DECLARE emp_part_cur FOR select name,age from emp where age>;25;
EXEC SQL OPEN emp_part_cur;
EXEC SQL FETCH emp_part_cur into :a_emp_part;
rec_count=sqlca.sqlerr[2]-accu_count;
accu_count=sqlca.sqlerr[2];
INSERT
emp_def a_emp[50];
在a_emp中准备N条记录。
a_emp[0].no=0; strcpy(a_emp[0].upd_ts,”20020101000000”); …
a_emp[1].no=1; strcpy(a_emp[1].upd_ts,”20020101000000”); …
…
a_emp[N-1].no=N-1; strcpy(a_emp[N-1].upd_ts,”20020101000000”); …
rec_count=N;
EXEC SQL for :rec_count insert into emp values(:a_emp);
8.3 编程框架
8.3.1 总体原则
为了使程序模块划分更加简洁清晰，提高应用程序的可移植性，所以采取将主程序模块和数据库功能模块分离的方法，即不在主程序逻辑中出现嵌入式sql语句，而把这些语句归并到数据库功能模块中去，对主程序而言，展现的是某种功能。同时在数据库模块上再进一步把通用功能和定制功能分割开来。 通用功能头文件和通用功能模块参见proc/single/dbcom.h和proc/single/dbcom.pc，定制功能头文件和定制功能模块参见proc/single/dbfunc.h和proc/single/dbfunc.pc，编译连接方法参见proc/single/Makefile。
8.3.2 单线程和多线程
由于嵌入式SQL语句被预编译成全局性的C数据结构和函数调用，所以在单线程条件下不会有任何执行问题，程序编写十分简单，参见proc/single/。
而多线程条件就复杂很多，为了保证多个线程能够安全互斥地使用全局数据结构，必须给每个线程一个表明身份的上下文标志（context），在进行sql操作时彼此能区别开来。
每个线程使用一个数据库连接，凭借自己的id使用专有的数据结构，包括上下文标志（context）等，此数据结构是数据库连接数组（a_thrd_conn）的一个成员，参见dbcom.h中thrd_conn_t和dbcom.c中a_thrd_conn。这样做的目的在于：统一存放连接有关数据，使线程引用变得简单。 加入多线程支持
在proc的命令行或配置文件pcscfg.cfg中写入threads=yes，表明为待编译的程序提供thread-safe功能，参见proc/multi/Makefile。
proc thread=yes …
应用程序中最前面必须指明本程序支持多线程，参见proc/multi/multi.c和proc/multi/dbcom.pc中DbsEnableThread。
EXEC SQL enable threads;
代码大致流程
每个线程使用线程编号（thrd_index）引用数据库连接数组。
在建立数据库连接的时候，分配上下文标志，参见proc/multi/dbcom.pc中DbsConnectThread。
EXEC SQL context allocate :a_thrd_conn[thrd_index].context;
断开时，释放上下文标志，参见DbsDisconnThread。
EXEC SQL context free :a_thrd_conn[thrd_index].context;
在每次sql操作前使用上下文标志（由于proc的一些原因，threads=yes条件下的sql语句在被proc转换时使用上面离其最近的use所指明的context，所以保险做法是每句sql语句前使用use）。
EXEC SQL context use : a_thrd_conn[thrd_index].context
EXEC SQL update emp set …;
8.3.3 开发工具
基于以下事实：宿主结构与表严格对应；基本SQL操作，如初始化宿主结构、SELECT(根据主键)、INSERT、DELETE(根据主键)、UPDATE(根据主键)等，流程非常单一。因此根据建表脚本生成宿主结构定义和基本SQL操作函数，可大大减少SQL操作函数的设计，提高开发速度。
工具由perl程序gendb和awk脚本mergedb.awk组成，由shell脚本chgdb组织流程。假定处理表emp，gendb根据表的创建脚本生成宿主结构定义（emp.h）和基本SQL操作函数（emp_auto.pc），mergedb.awk将宿主结构定义融入宿主结构所在头文件（dbfunc.h）。所有的文件或表的名称都在chgdb中定义，可以需要根据实际情况改写chgdb中部分内容。
使用方法：chgdb表名，如chgdb emp
参见chgdb
9 OCI—Oracle Call Interface
所有程序例子都在附件09_oci/下
OCI每个函数的参数都有很严格的类型定义，非常繁琐，下面的函数示例为了简洁说明起见，没有对参数类型作明确说明，也没有对错误进行处理，实际应用中要复杂得多。
9.1 连接和断开
9.1.1 句柄层次
OCI使用各种句柄操作数据库，环境句柄（Environment Handle）是所有句柄的父句柄下面列出开发所需的基本句柄。
服务器句柄（Server Handle），用户会话句柄（User Session Handle），事务句柄（Transaction Handle）隶属于服务上下文句柄（Service Context Handle），但都是以环境句柄为父句柄分配的。
查询输出定位句柄（Define Handle）和输入输出绑定变量句柄（Bind Handle）在执行具体的SQL语句的时候，被隐含创建并连接到表达句柄（Statement Handle）上，当表达句柄释放时，它们也被隐含释放。所以在执行每一个sql命令时，先分配表达句柄，执行结束后，释放表达句柄，这样做保证不发生由于定位句柄和绑定变量句柄引起的内存泄漏。
9.1.2 连接流程
参见dbcom.c中DbsConnect。
OCI连接过程十分复杂，除了分配设置各基本句柄外，还要明确彼此之间的联系，大致流程如下：
创建环境：
OCIEnvCreate(&handle_env…);
分配错误句柄：
OCIHandleAlloc(handle_env,&handle_error,OCI_HTYPE_ERROR,…);
分配设置服务上下文句柄和服务句柄：
OCIHandleAlloc(handle_env,&handle_service, OCI_HTYPE_SVCCTX,…);
OCIHandleAlloc(handle_env,&handle_server, OCI_HTYPE_SERVER,…);
OCIServerAttach(handle_server, handle_error,dblink,…); //初始化服务器句柄，为连接做好准备，如果dblink为NULL，则选择缺省数据库
OCIAttrSet(handle_service, OCI_HTYPE_SVCCTX, handle_server, 0, OCI_ATTR_SERVER, handle_error); //将服务器句柄连接到服务上下文句柄
分配设置会话句柄：
OCIHandleAlloc(handle_env,&handle_session, OCI_HTYPE_ SESSION,…);
OCIAttrSet(handle_session, OCI_HTYPE_SESSION, username, strlen(username), OCI_ATTR_USERNAME, handle_error); //向会话句柄填充用户名
OCIAttrSet(handle_session, OCI_HTYPE_SESSION, password, strlen(password), OCI_ATTR_PASSWORD, handle_error); //向会话句柄填充口令
建立会话连接：
OCISessionBegin(handle_service, handle_error, handle_session, OCI_CRED_RDBMS, OCI_DEFAULT); //发起连接
OCIAttrSet(handle_service, OCI_HTYPE_SVCCTX, handle_session, 0, OCI_ATTR_SESSION, handle_error);
9.1.3 断开流程
参见dbcom.c中DbsDisConnect。
当父句柄被释放时，与之连接的所有子句柄也被释放。大致流程如下：
断开会话连接：
OCISessionEnd(handle_service, handle_error,handle_session, OCI_DEFAULT);
去除服务器句柄：
OCIServerDetach(handle_server, handle_error,OCI_DEFAULT);
释放环境句柄：
OCIHandleFree(handle_env, OCI_HTYPE_ENV);
9.2 SQL语句
9.2.1 事务
提交：
OCITransCommit(handle_service,handle_error,OCI_DEFAULT);
回滚：
OCITransRollback(handle_service,handle_error,OCI_DEFAULT);
9.2.2 无结果集的sql语句
参见dbfunc.c中DbsRESUME_INS。
指insert,update,delete语句，执行以后它们只是返回错误值，因此可以用统一的形式完成。流程如下：
如执行这样一条sql语句：“insert into emp values(1,sysdate, ‘职员1’,’1’,30,2000)”。
OCIHandleAlloc(handle_env,&handle_stmt, OCI_HTYPE_STMT,0,NULL); //分配表达句柄
strcpy(sql, “insert into emp values(1,sysdate, ‘职员1’,’1’,30,2000)”);
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT); //解析sql语句
OCIStmtExecute(handle_service,handle_stmt,ThrdConn.p_herr,1, 0,NULL, NULL,OCI_DEFAULT); //加亮的1,0表示两个参数iters和rowoff,对于非select语句执行iters-rowoff次
OCIHandleFree(handle_stmt, OCI_HTYPE_STMT); //释放表达句柄
可以使用绑定变量的方式执行sql，例如：
假定输入数据都在指针p_emp指向的结构中。
……
strcpy(sql, “insert into emp values(:no,sysdate,:name,:duty,:age,:salary)”);
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,no,&p_emp->;no,sizeof(p_emp->;no),SQL_FLT,…);
OCIBindByName(handle_stmt, &a_handle_bind[1], handle_error,name,p_emp->;name,sizeof(p_emp->;name),SQL_STR,…);
OCIBindByName(handle_stmt, &a_handle_bind[2], handle_error,duty,p_emp->;duty,sizeof(p_emp->;duty),SQL_STR,…);
OCIBindByName(handle_stmt, &a_handle_bind[3], handle_error,age,&p_emp->;age,sizeof(p_emp->;age),SQL_INT,…);
OCIBindByName(handle_stmt, &a_handle_bind[4], handle_error,salary,&p_emp->;salary,sizeof(p_emp->;salary),SQL_FLT,…);
……
a_handle_bind是一个数组，成员为OCIBind *，上面说过，绑定变量句柄是绑定函数执行时隐含分配的，并隶属于表达句柄。对于定位句柄，也采取了相同的方式。
不过这种绑定的方法没有多大必要，因为可以直接把变量的值写作sql语句中，这个结论对下面的段落也有效，只不过为了描述的完整性，还是加入了绑定的内容。 9.2.3 有结果集的sql语句
选取
参见dbfunc.h中DbsEMP_SEL。
为了作更好的区分，这里的“选取”定义为根据唯一约束得到一条记录。这样与上面无结果集的sql语句相比，只是多了对输出的定义。流程如下：
如执行这样一条sql语句：“select no,upd_ts,name,duty,age,salary from emp where no=:no”，假定指针p_emp指向对应于表的宿主结构，输入条件在里面，输出也利用它。这句sql语句要求查询条件使用p_emp->;no，这就要把它绑定到输入变量上，并且要求输出no,upd_ts,name,duty,age,salary等域，所以必须对它们进行输出定位。
OCIHandleAlloc(handle_env,&handle_stmt, OCI_HTYPE_STMT,0,NULL); //分配表达句柄
strcpy(sql, “select no,upd_ts,name,duty,age,salary from emp where no=:no”);
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT); //解析sql语句
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,no,&p_emp->;no,sizeof(p_emp->;no),SQL_FLT,…); //p_emp->;no被绑定到输入
OCIDefineByPos(handle_stmt,&a_handle_define[0],handle_error,1,&p_emp->;no, sizeof(p_emp->;no), SQL_FLT, …); //p_emp->;no同时可作输出定位
OCIDefineByPos(handle_stmt,&a_handle_define[1],handle_error,2,p_emp->;upd_ts,sizeof(p_emp->;upd_ts), SQL_STR, …);
OCIDefineByPos(handle_stmt,&a_handle_define[2],handle_error,3,p_emp->;name,sizeof(p_emp->;name), SQL_STR, …);
OCIDefineByPos(handle_stmt,&a_handle_define[3],handle_error,4,p_emp->;duty,sizeof(p_emp->;duty), SQL_STR, …);
OCIDefineByPos(handle_stmt,&a_handle_define[4],handle_error,5,&p_emp->;age,sizeof(p_emp->;age), SQL_INT, …);
OCIDefineByPos(handle_stmt,&a_handle_define[5],handle_error,6,&p_emp->;salary,sizeof(p_emp->;salary), SQL_FLT, …);
OCIStmtExecute(handle_service,handle_stmt,ThrdConn.p_herr,1, 0,NULL, NULL,OCI_DEFAULT); //由于参数iters设为1,所以输出定位必须在执行前完成
OCIHandleFree(handle_stmt, OCI_HTYPE_STMT); //释放表达句柄
游标
参见09_oci/DbsEMP_CUR。
与上面“选取”相比，游标不强调查询条件的唯一性，而是处理成批的记录，这样就要有循环的结构和对输出区域的管理。流程如下：
如执行这样一条sql语句：“select no,name,age from emp where age<:age order by no”。
由于成批记录占用空间很难估计，所以在游标检索循环中根据实际情况分配和调整空间，回传给调用者的是指针。
strcpy(sql,” select no,name,age from emp where age<:age order by no”);
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT); //解析sql语句
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,age,&p_emp->;no,sizeof(p_emp->;age),SQL_INT,…);
OCIStmtExecute(handle_service,handle_stmt,handle_error,0,0, NULL,NULL,OCI_DEFAULT); //对照上面的“选取”，由于不知道记录数量，所以将参数iters设为0，仅仅打开游标，这也是执行前不进行输出定位的原因。
OCIDefineByPos(handle_stmt,&a_handle_define[0],handle_error,1,& emp.no, sizeof(emp.no), SQL_FLT, …);
OCIDefineByPos(handle_stmt,&a_handle_define[1],handle_error,2, emp.name,sizeof(emp.name), SQL_STR, …);
OCIDefineByPos(handle_stmt,&a_handle_define[2],handle_error,3,& emp.age,sizeof(emp->;age), SQL_INT, …);
while(1)
{
OCIStmtFetch2(handle_stmt, handle_error, 1,OCI_DEFAULT,0, OCI_DEFAULT); //加亮的1是参数nrows，意思是一次选取的记录条数，没有特别的要求，一般只取一条。
如果记录已取完，跳出循环。
将暂存的记录emp转移到记录数组a_emp中去。
判断并调整a_emp。
}
返回a_emp的指针和记录条数。 9.2.4 LOB
这里只描述了blob的操作情况，clob的情况大同小异。blob以字节为单位处理数据，不理会各种字符集的差异。
插入
参见dbfunc.c中DbsRESUME_INS。
分为两步，第一步与通常插入操作类似，但以sql函数empty_blob()代替类型为blob的域，流程如下：
sprintf(sql, "insert into resume values(:no,empty_blob())");
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,no,&p_emp->;no,sizeof(p_emp->;no),SQL_FLT,…);
OCIStmtExecute(handle_service,handle_stmt,handle_error,1, 0,NULL, NULL,OCI_DEFAULT);
第二步做一次选取，目的是将blob域与大对象定位句柄（OCILobLocate *handle_blob）连接起来，再把通过句柄把内容写到blob域中去，流程如下
sprintf(sql, "select resume from resume where no=:no");
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,no,&p_emp->;no,sizeof(p_emp->;no),SQL_FLT,…);
OCIDefineByPos(handle_stmt,&a_handle_define[0],handle_error,1,& handle_blob,sizeof(handle_blob), SQL_BLOB, …);
OCIStmtExecute(handle_service,handle_stmt,handle_error,1, 0,NULL, NULL,OCI_DEFAULT);
写blob公用函数（write_blob），参见dbcom.c中write_blob。
为了不一次写入过多数据，首先定义一个缓冲区大小LOB_BUF_LEN，比如规定为8192。
如果写入数据大小（size）在LOB_BUF_LEN范围内，则可一次写完。
amt=size;
OCILobWrite(handle_service,handle_error,p_blob, &amt, 1,write_buf, buf_len, OCI_ONE_PIECE,…);
//p_blob是大对象定位句柄
//amt输入要写的字节数，并输出实际写的字节数，当前情况下，两个数值一样
//加亮的1表示缓冲区开始写的位移，1为起始位置
//OCI_ONE_PIECE表示一次写完
如果写入数据超过LOB_BUF_LEN范围，必须分多次写入。
先写入第一批数据：
offset=1; amt=LOB_BUF_LEN; remainder=size; //offset记录已写的位置，remainder记录剩下的数据字节数
OCILobWrite(handle_service,handle_error,p_blob, &amt, offset,write_buf, buf_len,OCI_FIRST_PIECE,…); //OCI_FIRST_PIECE表示写第一批
remainder-=amt; offset+=amt;
展开循环：
while(remainder>;LOB_BUF_LEN)
{
amt=LOB_BUF_LEN; //每次写LOB_BUF_LEN大小的数据
OCILobWrite(handle_service, handle_error,p_blob, &amt, offset,write_buf, buf_len, OCI_NEXT_PIECE,…); //OCI_NEXT_PIECE表示继续写，但不写最后一批
remainder-=amt; offset+=amt;
}
写入最后一批数据：
amt=remainder;
OCILobWrite(handle_service,handle_error,p_blob, &amt, offset,write_buf, buf_len,OCI_LAST_PIECE,…); //OCI_LAST_PIECE表示写最后一批数据
选取
参见09_oci/DbsRESUME_SEL。
分为两步，第一步与通常选取操作类似，但对应blob域的定位句柄是大对象定位句柄，流程如下：
sprintf(sql, "select no,resume from resume where no=:no");
OCIStmtPrepare(handle_stmt, handle_error, sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
OCIBindByName(handle_stmt, &a_handle_bind[0], handle_error,no,&p_emp->;no,sizeof(p_emp->;no),SQL_FLT,…);
OCIDefineByPos(handle_stmt,&a_handle_define[0],handle_error,1,&p_emp->;no, sizeof(p_emp->;no), SQL_FLT, …);
OCIDefineByPos(handle_stmt,&a_handle_define[1],handle_error,2,&handle_blob, sizeof(handle_blob), SQL_BLOB, …); //handle_blob必须事先分配
OCIStmtExecute(handle_service,handle_stmt,ThrdConn.p_herr,1, 0,NULL, NULL,OCI_DEFAULT);
第二步通过大对象定位句柄调用读blob公用函数（read_blob），参见dbcom.c中read_blob。
取得blob域数据长度（size）：
OCILobGetLength(handle_service,handle_error,p_blob, &size)
展开读取循环：
remainder=size; offset=1;
while(1)
{
amt=0; //输入要写的字节数为0,使用流模式（streamed mode）读取
OCILobRead(handle_service,handle_error,p_blob,&amt,1,read_buf+offset-1, (ub4)LOB_BUF_LEN,NULL,NULL …);
//加亮的1表示第一次读的位移，在流模式下，此参数和amt一样，只有在第一次读时有效
//加亮的NULL表示回调函数为空，这样流模式使用轮询（polling）方法而不是回调（callback）方法
//轮询方法下，如果没有读到blob末尾，函数返回OCI_NEED_DATA，读取完毕，返回OCI_SUCCESS
如果读取完毕（OCI_NEED_DATA），跳出循环
offset+=amt; remainder-=amt;
}
read_buf[size]='\0';
9.3 编程框架
9.3.1 总体原则
为了使程序模块划分更加简洁清晰，提高应用程序的可移植性，所以采取将主程序模块和数据库功能模块分离的方法，即不在主程序逻辑中出现OCI函数调用，而把这些调用归并到数据库功能模块中去，对主程序而言，展现的是某种功能。同时在数据库模块上再进一步把通用功能和定制功能分割开来。
通用功能头文件和通用功能模块参见dbcom.h和dbcom.c，定制功能头文件和定制功能模块参见dbfunc.h和dbfunc.c。
支持多线程编程，线程共享一个环境句柄（测试中发现环境句柄分配超出5个就会出错，因此采用共享方式），参见dbcom.h中p_henv的定义。
每个线程使用一个数据库连接，凭借自己的id使用专有的数据结构，包括错误句柄、上下文句柄、服务器句柄、会话句柄、表达句柄、输入绑定句柄数组、输出定位句柄数组、sql语句缓冲区等，此数据结构是数据库连接数组（a_thrd_conn）的一个成员，参见dbcom.h中thrd_conn_t和dbcom.c中a_thrd_conn。这样做的目的在于：避免在每个sql函数处作繁琐的定义，通过一些简化的写法，使编程更简洁。 9.3.2 sql语句
参见dbcom.h。
由于OCI函数参数及其繁琐，而使用方式又比较单一，加之引用规范化的数据结构，所以在选取规范化的函数调用的基础上，可用宏对其进行大幅度简化。
首先定义的宏是连接对数据库连接数组的引用：
#define ThrdConn a_thrd_conn[thrd_index] //thrd_index是每个连接的编号
prepare
OCIStmtPrepare(ThrdConn.p_hstmt, ThrdConn.p_herr, ThrdConn.sql, (ub4)strlen((char *)ThrdConn.sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT)
简化为StmtPrepare。
execute
OCIStmtExecute(ThrdConn.p_hsvc, ThrdConn.p_hstmt, ThrdConn.p_herr, (ub4)1, (ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_DEFAULT)
简化为StmtExecute。
open
OCIStmtExecute(ThrdConn.p_hsvc, ThrdConn.p_hstmt,ThrdConn.p_herr, (ub4)0, (ub4)0,(CONST OCISnapshot *)NULL, (OCISnapshot *)NULL,OCI_DEFAULT)
简化为StmtOpen，注意与execute的不同。
fetch
OCIStmtFetch2(ThrdConn.p_hstmt, ThrdConn.p_herr,(ub4)1, (ub2)OCI_DEFAULT, (sb4)0, (ub4)OCI_DEFAULT)
简化为StmtFetch
define
按输出顺序将输出定位句柄联系至实体缓冲区。
OCIDefineByPos(ThrdConn.p_hstmt, &ThrdConn.a_hdef[Pos-1], ThrdConn.p_herr, (ub4)Pos, (dvoid *)Host, (sb4)Size, (ub2)Type,(dvoid *)NULL, (ub2 *)NULL, (ub2 *)NULL, OCI_DEFAULT)
简化为DefinePos(Pos,Host,Size,Type)
bind
将宿主变量名（即sql语句中:col）将输入绑定句柄联系到实体缓冲区。
OCIBindByName(ThrdConn.p_hstmt, &ThrdConn.a_hbnd[Order-1],ThrdConn.p_herr,(CONST text *)":"#Name, (sb4)-1,(dvoid *)Host, (sb4)Size, (ub2)Type,(dvoid *)NULL, (ub2 *)NULL, (ub2 *)NULL,(ub4)0, (ub4 *)NULL, OCI_DEFAULT)
简化为BindName(Order,Name,Host,Size,Type)
按输入宿主变量顺序将输入绑定句柄联系到实体缓冲区。
OCIBindByPos(ThrdConn.p_hstmt, &ThrdConn.a_hbnd[Pos-1],ThrdConn.p_herr, (ub4)Pos, (dvoid *)Host, (sb4)Size, (ub2)Type, (dvoid *)NULL, (ub2 *)NULL, (ub2 *)NULL,(ub4)0, (ub4 *)NULL, OCI_DEFAULT)
简化为BindPos(Pos,Host,Size,Type)
9.3.3 函数
基于以上的简化，可以将sql操作归到几个简单的标准化函数模式中去。函数至少必须拥有两个参数：数据库连接编号（int thrd_indx）和sql语句（char *sql）。函数体定义部分必须使用DefaultDefinition，程序部分头尾分别使用StartFunc和EndFunc。
无结果集的sql
参见dbcom.c中DbsSQLExec。
在9.2.2中已经提到，输入绑定是没必要的，这样象update、delete、insert的操作都可以用一个统一的执行函数就能解决。
int DbsSQLExec(int thrd_index, char *sql)
{
strcpy(ThrdConn.sql, sql); //之所以多复制了一次，是因为照顾到各定义的通用性
StmtPrepare;
StmtExecute;
}
选取一条记录
参见dbfunc.c中DbsEMP_SEL。
输入绑定和输出定位由于情况复杂不能省略，因此选取必须用单独定制的sql函数。建议在应用程序中先定义一个对应表结构的宿主结构，将其地址传入sql函数，可以将这个宿主结构同时作为输入条件和输出数据的缓冲区。
int DbsEMP_SEL(int thrd_index, char *sql, emp_t *p_emp)
{
strcpy(ThrdConn.sql, sql);
StmtPrepare;
BindName(…);
DefinePos(…);
StmtExecute;
}
游标
游标的流程大致如下：
解析sql语句
绑定输入
打开游标
定位输出
分配输出空间
展开循环
{
读取游标
如已读完，跳出循环
检查输出空间，如已满，则分配更多的空间
}
返回输出空间的引用
参见dbcom.h，dbfunc.h中DbsEMP_CUR。
前4步操作由于情况多变，不能成为标准化过程，而后面的步骤则可成为一种模式，定义如下：
#define ProcCursor(Table) \
do \
{ \
InitCurBuf(Table); \ //分配输出空间
while(1) \
{ \
CheckErr(StmtFetch); \ //读取游标
if(status!=OCI_SUCCESS && status!=OCI_NO_DATA) \
goto ERROR; \
if(status==OCI_NO_DATA) break; \ //如已读完，跳出循环
CurBufLast(Table)=Table; \
ExpandCurBuf(Table); \ //检查输出空间
} \
*pa_##Table=CurBuf(Table); \ //返回输出空间的引用
*p_##Table##_qt=Table##_real_qt; \
} while(0);
为了实现流程的标准化，定义使用了一些保留字，假定Table为emp，输出空间指针a_emp，辅助变量emp_alloc_qt和emp_real_qt，编译时被自动定义出来。同时要求游标所在的函数传入输出空间指针地址（emp_t **pa_emp）和记录条数变量地址（int *p_emp_qt）。
注意加亮的一行，因为输出定位在循环开始之前必须联系到某个结构实体，所以这里利用了那个实体，作了一次转存。这个实体在DefCurBuf(Table)里定义，名字即为表名。
与“选取”类似，建议使用宿主结构指针传入输入条件。
int DbsEMP_CUR(int thrd_index,char *sql,emp_t *p_emp,emp_t **pa_emp,int *p_emp_qt)
{
DefCurBuf(emp); //定义输出空间指针和几个辅助变量
strcpy(ThrdConn.sql, sql);
StmtPrepare;
BindName(…);
StmtOpen;
DefinePos(1, &emp.no, sizeof(emp.no), SQLT_FLT));
ProcCursor(emp);
} 10 附录—MYSQL
MYSQL作为一个小巧、灵活、高效的开源数据库，可以作为象Oracle这样的大型商业数据库的有益补充。并不是所有场合都需要Oracle等数据库的高可靠性和高可扩展性，没有必要盲目支付昂贵的软件费用。所以在本附录里作一点介绍。
10.1 安装配置
笔者选择的安装平台是RedHat Linux 7.3，在mysql的网站[url]www.mysql.com[/url]里有rpm格式的安装文件，版本号3.23.52的标准版，包括Server、Benchmark/test suites、Client programs、Libraries and Header files for development、Client shared libraries等数个rpm文件。
以root用户登录，依次安装rpm包，大致顺序先装库，再装server，client。
安装结束后，mysql已经启动。下面对数据库作一些调整。
以root用户登录。
关闭数据库：
mysqladmin shutdown -uroot
mysql的启动脚本是/usr/bin/safe_mysqld，打开它，找到MY_BASEDIR_VERSION, DATADIR,ledir所在的区域，这是一个if … then … elif … then … else … fi的结构，到最后一个else块，修改这三个变量为：
MY_BASEDIR_VERSION=/
DATADIR=/opt/mysql #数据库所在目录
ledir=/usr/sbin #mysql系统程序mysqld所在目录
原来的DATADIR为/var/lib/mysql，肯定要根据实际情况改变的。
将/var/lib/mysql/下的mysql目录复制到新的DATADIR即/opt/mysql下。
在/usr/share/doc/packages/MySQL下能找到my.cnf的不同配置，选一个符合实际情况的配置，复制成/etc/my.cnf。
启动数据库：
safe_mysqld &
mysql在安装过程中产生/etc/init.d/mysql，设置各/etc/rc.d对它的符号连接，这样mysql的启动关闭可以让操作系统自动完成。
10.2 管理
10.2.1 初始调整
第一次进入mysql，没有任何验证。
以root用户登录mysql：
mysql -uroot
选择数据库mysql，即mysql的系统数据库：
mysql>;use mysql
操作数据字典，重新设置root用户口令：
在数据库mysql中，db,user和host构成了最基本的数据字典，主要功能为检查数据库连接的有效性。
mysql>;delete from user where user<>;’root’;
mysql>;update user set password=password(‘mysql’) where user=’root’;
建立新数据库：
mysql>;create database data;
去除数据库：drop database data;
建立普通用户dbuser，赋予权限：
mysql>;insert into user (host,user,password) values(‘%’,’dbuser’,password(‘mysql’)); #表名和域列表之间一定要有空格，如user (…)
mysql>;grant select,insert,update,delete,create,drop,index,alter on data.* to dbuser;
重载mysql系统信息：
mysql>;exit
mysqladmin reload –uroot
从此以后，对root用户的验证已经建立起来，这样使用mysqladmin的操作必须加上口令验证：
mysqladmin shutdown –uroot –pmysql
mysqladmin reload –uroot -pmysql
10.2.2 建立用户对象
登录：
mysql data –udbuser –pmysql
mysql>;show databases; #显示现有的数据库
mysql>;show tables; #显示本数据库中的表
mysql>;show columns from emp; #显示表结构
mysql>;desc emp; #与上面相同
mysql>;show index from emp; #显示表所有的索引
mysqll>;show status; #显示系统配置信息
mysql>;show table status; #显示表状态
mysql>;show grants for dbuser; #显示用户所有的权限
建立表和索引：
mysql>;create table emp(no numeric(12) not null,upd_ts timestamp not null,…);
mysql>;drop table emp;
mysql>;alter table emp add primary key (no);
mysql>;alter table drop primary key;
mysql>;alter table emp add index emp_x01 (name);
mysql>;alter table drop index emp_x01;
也可以将sql语句写成一个脚本，重定向到mysql中去：
mysql data –udbuser –pmysql <db.sql
10.3 开发
参见附件10_mysql/
10.3.1 连接和断开
首先定义数据库连接的数据结构mysql以及衍生的连接句柄sock（参见dbcom.h）：
MYSQL mysql;
MYSQL *sock;
为了简化编程，将本连接的res（资源句柄），row（域指针数组）和sql（sql语句缓冲区）也一起定义好：
MYSQL_RES *res;
MYSQL_ROW row;
char *sql;
建立连接（参见dbcom.c中DbsConnect）：
mysql_init(&mysql);
sock=mysql_real_connect(&mysql, host, username, password, dbname, 0, NULL, 0));
如果是本机，则host为NULL。
username（数据库用户名）,password（口令）,dbname（数据库名）是”dbuser”,”mysql”,”data”这样的组合。
sql=(char *)malloc(…);
断开连接（参见dbcom.c中DbsDisConnect）：
mysql_close(sock);
free(sql); 10.3.2 无结果集的sql语句
参见dbfunc.c中DbsRESUME_INS。
指insert,update,delete语句，执行以后它们只是返回错误值，因此可以用统一的形式完成。
strcpy(sql, “insert into emp values(…)”);
mysql_query(sock, sql)；
10.3.3 有结果集的sql
指select语句，为简化编程，这里分两种情况：根据unique约束的select和根据一般条件的select，前者可以写得更简洁一些。笔者把前者称之为“选取”，后者为“游标”。
选取：
参见dbfunc.c中DbsEMP_SEL。
strcpy(sql, “select name from emp where no=1”);
mysql_query(sock, sql);
res=mysql_store_result(sock); #将结果集从mysql服务端读取到客户端
row=mysql_fetch_row(res); #获取本记录域指针
strcpy(name,row[0]); #根据选取域位置复制到用户数据结构中
mysql_free_result(res); #释放记录内容
游标：
参见dbfunc.c中DbsEMP_CUR。
strcpy(sql, “select name from emp where age>;20”);
mysql_query(sock, sql);
res=mysql_use_result(sock);
count=0;
展开游标循环
{
row=mysql_fetch_row(res);
如果已经选完，跳出循环;
strcpy(name[count],row[0]);
count++;
}
mysql_free_result(res);
10.3.4 错误处理
参见dbcom.c中checkerr。
根据文档判断mysql函数调用是否错误。
mysql_errno(sock)指明错误码。
mysql_error(sock)显示错误说明文本。
unsigned int result=mysql_errno(sock);
if(result)
{
printf("errno:%d errmsg:%s\n", result, mysql_error(sock));
}
return result;
有些函数的返回值可能代表正确也可能代表错误，此时必须进行错误判断，如mysql_fetch_row取完最后一条记录后返回的是NULL，而出错也返回NULL，前者为正常情况。
注意mysql错误码处理与其它数据库的不同，如mysql_fetch_row，取完记录并不产生“记录已取完”的错误信息，而是产生“成功”信息。
页:
[1]