﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>C++博客-时间的痕迹-文章分类-数据库</title><link>http://www.cppblog.com/ivenher/category/2687.html</link><description /><language>zh-cn</language><lastBuildDate>Wed, 21 May 2008 11:40:03 GMT</lastBuildDate><pubDate>Wed, 21 May 2008 11:40:03 GMT</pubDate><ttl>60</ttl><item><title> sql server锁机制 </title><link>http://www.cppblog.com/ivenher/articles/22136.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Tue, 17 Apr 2007 08:03:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/22136.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/22136.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/22136.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/22136.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/22136.html</trackback:ping><description><![CDATA[<div class=postText twffan="done">
<p><font color=#000000>作者：宋立桓<br><br>[导读: 各种大型数据库所采用的锁的基本理论是一致的，但在具体实现上各有差别。SQL Server更强调由系统来管理锁。在用户有SQL请求时，系统分析请求，自动在满足锁定条件和系统性能之间为数据库加上适当的锁，同时系统在运行期间常常自动进行优化处理，实行动态加锁。对于一般的用户而言，通过系统的自动锁定管理机制基本可以满足使用要求，但如果对数据安全、数据库完整性和一致性有特殊要求，就需要了解SQL Server的锁机制，掌握数据库锁定方法。]&nbsp;&nbsp; </font></p>
<p><font color=#000000>&nbsp;&nbsp;&nbsp; 锁是数据库中的一个非常重要的概念，它主要用于多用户环境下保证数据库完整性和一致性。 我们知道，多个用户能够同时操纵同一个数据库中的数据，会发生数据不一致现象。即如果没有锁定且多个用户同时访问一个数据库，则当他们的事务同时使用相同的数据时可能会发生问题。这些问题包括：丢失更新、脏读、不可重复读和幻觉读：<br>1．当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，会发生丢失更新问题。每个事务都不知道其它事务的存在。最后的更新将重写由其它事务所做的更新，这将导致数据丢失。例如，两个编辑人员制作了同一文档的电子复本。每个编辑人员独立地更改其复本，然后保存更改后的复本，这样就覆盖了原始文档。最后保存其更改复本的编辑人员覆盖了第一个编辑人员所做的更改。如果在第一个编辑人员完成之后第二个编辑人员才能进行更改，则可以避免该问题。<br>2. 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。例如，一个编辑人员正在更改电子文档。在更改过程中，另一个编辑人员复制了该文档（该复本包含到目前为止所做的全部更改）并将其分发给预期的用户。此后，第一个编辑人员认为目前所做的更改是错误的，于是删除了所做的编辑并保存了文档。分发给用户的文档包含不再存在的编辑内容，并且这些编辑内容应认为从未存在过。如果在第一个编辑人员确定最终更改前任何人都不能读取更改的文档，则可以避免该问题。<br>3．不可重复读是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。例如，一个编辑人员两次读取同一文档，但在两次读取之间，作者重写了该文档。当编辑人员第二次读取文档时，文档已更改。原始读取不可重复。如果只有在作者全部完成编写后编辑人员才可以读取文档，则可以避免该问题。<br>4．幻觉读是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。例如，一个编辑人员更改作者提交的文档，但当生产部门将其更改内容合并到该文档的主复本时，发现作者已将未编辑的新材料添加到该文档中。如果在编辑人员和生产部门完成对原始文档的处理之前，任何人都不能将新材料添加到文档中，则可以避免该问题。<br>所以，处理多用户并发访问的方法是加锁。锁是防止其他事务访问指定的资源控制、实现并发控制的一种主要手段。当一个用户锁住数据库中的某个对象时，其他用户就不能再访问该对象。加锁对并发访问的影响体现在锁的粒度上。为了控制锁定的资源，应该首先了解系统的空间管理。在SQL Server 2000系统中，最小的空间管理单位是页，一个页有8K。所有的数据、日志、索引都存放在页上。另外，使用页有一个限制，这就是表中的一行数据必须在同一个页上，不能跨页。页上面的空间管理单位是盘区，一个盘区是8个连续的页。表和索引的最小占用单位是盘区。数据库是由一个或者多个表或者索引组成，即是由多个盘区组成。放在一个表上的锁限制对整个表的并发访问；放在盘区上的锁限制了对整个盘区的访问；放在数据页上的锁限制了对整个数据页的访问；放在行上的锁只限制对该行的并发访问。</font></p>
<p><font color=#000000>SQL Server 2000 具有多粒度锁定，允许一个事务锁定不同类型的的资源。为了使锁定的成本减至最少，SQL Server 自动将资源锁定在适合任务的级别。锁定在较小的粒度（例如行）可以增加并发但需要较大的开销，因为如果锁定了许多行，则需要控制更多的锁。锁定在较大的粒度（例如表）就并发而言是相当昂贵的，因为锁定整个表限制了其它事务对表中任意部分进行访问，但要求的开销较低，因为需要维护的锁较少。SQL Server 可以锁定行、页、扩展盘区、表、库等资源。<br>行是可以锁定的最小空间, 行级锁占用的数据资源最少，所以在事务的处理过程中，允许其他事务继续操纵同一个表或者同一个页的其他数据，大大降低了其他事务等待处理的时间，提高了系统的并发性。<br>页级锁是指在事务的操纵过程中，无论事务处理数据的多少，每一次都锁定一页，在这个页上的数据不能被其他事务操纵。在SQL Server 7.0以前，使用的是页级锁。页级锁锁定的资源比行级锁锁定的数据资源多。在页级锁中，即使是一个事务只操纵页上的一行数据，那么该页上的其他数据行也不能被其他事务使用。因此，当使用页级锁时，会出现数据的浪费现象，也就是说，在同一个页上会出现数据被占用却没有使用的现象。在这种现象中，数据的浪费最多不超过一个页上的数据行。<br>表级锁也是一个非常重要的锁。表级锁是指事务在操纵某一个表的数据时，锁定了这个数据所在的整个表，其他事务不能访问该表中的其他数据。当事务处理的数据量比较大时，一般使用表级锁。表级锁的特点是使用比较少的系统资源，但是却占用比较多的数据资源。与行级锁和页级锁相比，表级锁占用的系统资源例如内存比较少，但是占用的数据资源却是最大。在表级锁时，有可能出现数据的大量浪费现象，因为表级锁锁定整个表，那么其他的事务都不能操纵表中的其他数据。<br>盘区锁是一种特殊类型的锁，只能用在一些特殊的情况下。簇级锁就是指事务占用一个盘区，这个盘区不能同时被其他事务占用。例如在创建数据库和创建表时，系统分配物理空间时使用这种类型的锁。系统是按照盘区分配空间的。当系统分配空间时，使用盘区锁，防止其他事务同时使用同一个盘区。当系统完成分配空间之后，就不再使用这种类型的盘区锁。特别是，当涉及到对数据操作的事务时，不使用盘区锁。<br>数据库级锁是指锁定整个数据库，防止任何用户或者事务对锁定的数据库进行访问。数据库级锁是一种非常特殊的锁，它只是用于数据库的恢复操作过程中。这种等级的锁是一种最高等级的锁，因为它控制整个数据库的操作。只要对数据库进行恢复操作，那么就需要设置数据库为单用户模式，这样系统就能防止其他用户对该数据库进行各种操作。<br>行级锁是一种最优锁，因为行级锁不可能出现数据既被占用又没有使用的浪费现象。但是，如果用户事务中频繁对某个表中的多条记录操作，将导致对该表的许多记录行都加上了行级锁，数据库系统中锁的数目会急剧增加，这样就加重了系统负荷，影响系统性能。因此，在SQL Server中，还支持锁升级(lock escalation)。所谓锁升级是指调整锁的粒度，将多个低粒度的锁替换成少数的更高粒度的锁，以此来降低系统负荷。在SQL Server中当一个事务中的锁较多，达到锁升级门限时，系统自动将行级锁和页面锁升级为表级锁。特别值得注意的是，在SQL Server中，锁的升级门限以及锁升级是由系统自动来确定的，不需要用户设置。<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 在SQL&nbsp; Server数据库中加锁时，除了可以对不同的资源加锁，还可以使用不同程度的加锁方式，即锁有多种模式，SQL Server中锁模式包括：&nbsp;&nbsp;&nbsp;&nbsp; <br>1．共享锁&nbsp;&nbsp;&nbsp;&nbsp; SQL Server中，共享锁用于所有的只读数据操作。共享锁是非独占的，允许多个并发事务读取其锁定的资源。默认情况下，数据被读取后，SQL Server立即释放共享锁。例如，执行查询&#8220;SELECT&nbsp; *&nbsp; FROM&nbsp; AUTHORS&#8221;时，首先锁定第一页，读取之后，释放对第一页的锁定，然后锁定第二页。这样，就允许在读操作过程中，修改未被锁定的第一页。但是，事务隔离级别连接选项设置和SELECT语句中的锁定设置都可以改变SQL Server的这种默认设置。例如，&#8220; SELECT&nbsp; *&nbsp; FROM&nbsp; AUTHORS&nbsp; HOLDLOCK&#8221;就要求在整个查询过程中，保持对表的锁定，直到查询完成才释放锁定。&nbsp;&nbsp;&nbsp; <br>&nbsp;2．更新锁&nbsp;&nbsp;&nbsp;&nbsp; 更新锁在修改操作的初始化阶段用来锁定可能要被修改的资源，这样可以避免使用共享锁造成的死锁现象。因为使用共享锁时，修改数据的操作分为两步，首先获得一个共享锁，读取数据，然后将共享锁升级为排它锁，然后再执行修改操作。这样如果同时有两个或多个事务同时对一个事务申请了共享锁，在修改数据的时候，这些事务都要将共享锁升级为排它锁。这时，这些事务都不会释放共享锁而是一直等待对方释放，这样就造成了死锁。如果一个数据在修改前直接申请更新锁，在数据修改的时候再升级为排它锁，就可以避免死锁。<br>3．排它锁&nbsp;&nbsp;&nbsp;&nbsp; 排它锁是为修改数据而保留的。它所锁定的资源，其他事务不能读取也不能修改。&nbsp;&nbsp; <br>4．结构锁&nbsp;&nbsp;&nbsp;&nbsp; 执行表的数据定义语言 (DDL) 操作（例如添加列或除去表）时使用架构修改 (Sch-M) 锁。当编译查询时，使用架构稳定性 (Sch-S) 锁。架构稳定性 (Sch-S) 锁不阻塞任何事务锁，包括排它锁。因此在编译查询时，其它事务（包括在表上有排它锁的事务）都能继续运行。但不能在表上执行 DDL 操作。<br>5．意向锁&nbsp;&nbsp;&nbsp;&nbsp; 意向锁说明SQL Server有在资源的低层获得共享锁或排它锁的意向。例如，表级的共享意向锁说明事务意图将排它锁释放到表中的页或者行。意向锁又可以分为共享意向锁、独占意向锁和共享式独占意向锁。共享意向锁说明事务意图在共享意向锁所锁定的低层资源上放置共享锁来读取数据。独占意向锁说明事务意图在共享意向锁所锁定的低层资源上放置排它锁来修改数据。共享式排它锁说明事务允许其他事务使用共享锁来读取顶层资源，并意图在该资源低层上放置排它锁。&nbsp;&nbsp;&nbsp;&nbsp; <br>6．大容量更新锁&nbsp; 当将数据大容量复制到表，且指定了 TABLOCK 提示或者使用 sp_tableoption 设置了 table lock on bulk 表选项时，将使用大容量更新 锁。大容量更新锁允许进程将数据并发地大容量复制到同一表，同时防止其它不进行大容量复制数据的进程访问该表。<br>&nbsp;&nbsp;&nbsp; <br>SQL Server系统中建议让系统自动管理锁，该系统会分析用户的SQL语句要求，自动为该请求加上合适的锁，而且在锁的数目太多时，系统会自动进行锁升级。如前所述，升级的门限由系统自动配置，并不需要用户配置。 在实际应用中，有时为了应用程序正确运行和保持数据的一致性，必须人为地给数据库的某个表加锁。比如，在某应用程序的一个事务操作中，需要根据一编号对几个数据表做统计操作，为保证统计数据时间的一致性和正确性，从统计第一个表开始到全部表结束，其他应用程序或事务不能再对这几个表写入数据，这个时候，该应用程序希望在从统计第一个数据表开始或在整个事务开始时能够由程序人为地（显式地）锁定这几个表，这就需要用到手工加锁（也称显式加锁）技术。<br>可以使用 SELECT、INSERT、UPDATE 和 DELETE 语句指定表级锁定提示的范围，以引导 Microsoft&nbsp; SQL Server 2000 使用所需的锁类型。当需要对对象所获得锁类型进行更精细控制时，使用表级锁定提示更改默认的锁定行为。<br>所指定的表级锁定提示有如下几种：&nbsp;&nbsp;&nbsp; <br>1． HOLDLOCK: 在该表上保持共享锁，直到整个事务结束，而不是在语句执行完立即释放所添加的锁。&nbsp;&nbsp;&nbsp;&nbsp; <br>2． NOLOCK：不添加共享锁和排它锁，当这个选项生效后，可能读到未提交读的数据或&#8220;脏数据&#8221;，这个选项仅仅应用于SELECT语句。&nbsp;&nbsp;&nbsp;&nbsp; <br>3． PAGLOCK：指定添加页锁（否则通常可能添加表锁）。&nbsp;&nbsp; <br>4． READCOMMITTED用与运行在提交读隔离级别的事务相同的锁语义执行扫描。默认情况下，SQL Server 2000 在此隔离级别上操作。。&nbsp;&nbsp; <br>5． READPAST: 跳过已经加锁的数据行，这个选项将使事务读取数据时跳过那些已经被其他事务锁定的数据行，而不是阻塞直到其他事务释放锁，READPAST仅仅应用于READ COMMITTED隔离性级别下事务操作中的SELECT语句操作。&nbsp;&nbsp;&nbsp; <br>6． READUNCOMMITTED：等同于NOLOCK。&nbsp;&nbsp;&nbsp;&nbsp; <br>7． REPEATABLEREAD：设置事务为可重复读隔离性级别。&nbsp;&nbsp; <br>8． ROWLOCK：使用行级锁，而不使用粒度更粗的页级锁和表级锁。&nbsp;&nbsp;&nbsp; <br>9． SERIALIZABLE：用与运行在可串行读隔离级别的事务相同的锁语义执行扫描。等同于 HOLDLOCK。&nbsp; <br>10． TABLOCK：指定使用表级锁，而不是使用行级或页面级的锁，SQL Server在该语句执行完后释放这个锁，而如果同时指定了HOLDLOCK，该锁一直保持到这个事务结束。&nbsp;&nbsp;&nbsp;&nbsp; <br>11． TABLOCKX：指定在表上使用排它锁，这个锁可以阻止其他事务读或更新这个表的数据，直到这个语句或整个事务结束。&nbsp;&nbsp; <br>12． UPDLOCK ：指定在读表中数据时设置更新 锁（update lock）而不是设置共享锁，该锁一直保持到这个语句或整个事务结束，使用UPDLOCK的作用是允许用户先读取数据（而且不阻塞其他用户读数据），并且保证在后来再更新数据时，这一段时间内这些数据没有被其他用户修改。&nbsp;&nbsp;&nbsp; <br>死锁问题<br>在数据库系统中，死锁是指多个用户（进程）分别锁定了一个资源，并又试图请求锁定对方已经锁定的资源，这就产生了一个锁定请求环，导致多个用户（进程）都处于等待对方释放所锁定资源的状态。这种死锁是最典型的死锁形式, 例如在同一时间内有两个事务A和B，事务A有两个操作：锁定表part和请求访问表supplier；事务B也有两个操作：锁定表supplier和请求访问表part。结果，事务A和事务B之间发生了死锁。<br>&nbsp;&nbsp;&nbsp; 死锁的第二种情况是，当在一个数据库中时，有若干个长时间运行的事务执行并行的操作，当查询分析器处理一种非常复杂的查询例如连接查询时，那么由于不能控制处理的顺序，有可能发生死锁现象。<br>&nbsp;&nbsp;&nbsp; 在SQL Server中，系统能够自动定期搜索和处理死锁问题。系统在每次搜索中标识所有等待锁定请求的进程会话，如果在下一次搜索中该被标识的进程仍处于等待状态，SQL Server就开始递归死锁搜索。当搜索检测到锁定请求环时，SQL Server 通过自动选择可以打破死锁的线程（死锁牺牲品）来结束死锁。SQL Server 回滚作为死锁牺牲品的事务，通知线程的应用程序（通过返回 1205 号错误信息），取消线程的当前请求，然后允许不间断线程的事务继续进行。SQL Server 通常选择运行撤消时花费最少的事务的线程作为死锁牺牲品。另外，用户可以使用 SET 语句将会话的 DEADLOCK_PRIORITY 设置为 LOW。DEADLOCK_PRIORITY 选项控制在死锁情况下如何衡量会话的重要性。如果会话的设置为 LOW ，则当会话陷入死锁情况时将成为首选牺牲品。<br>&nbsp;&nbsp;&nbsp; 理解了死锁的概念，在应用程序中就可以采用下面的一些方法来尽量避免死锁了： （1）合理安排表访问顺序。 （2）在事务中尽量避免用户干预，尽量使一个事务处理的任务少些, 保持事务简短并在一个批处理中。 （3）数据访问时域离散法, 数据访问时域离散法是指在客户机/服务器结构中，采取各种控制手段控制对数据库或数据库中的对象访问时间段。主要通过以下方式实现: 合理安排后台事务的执行时间，采用工作流对后台事务进行统一管理。工作流在管理任务时，一方面限制同一类任务的线程数（往往限制为1个），防止资源过多占用; 另一方面合理安排不同任务执行时序、时间，尽量避免多个后台任务同时执行，另外， 避免在前台交易高峰时间运行后台任务。 （4）数据存储空间离散法。数据存储空间离散法是指采取各种手段，将逻辑上在一个表中的数据分散到若干离散的空间上去，以便改善对表的访问性能。主要通过以下方法实现: 第一，将大表按行或列分解为若干小表; 第二，按不同的用户群分解。 （5）使用尽可能低的隔离性级别。隔离性级别是指为保证数据库数据的完整性和一致性而使多用户事务隔离的程度，SQL92定义了4种隔离性级别：未提交读、提交读、可重复读和可串行。如果选择过高的隔离性级别，如可串行，虽然系统可以因实现更好隔离性而更大程度上保证数据的完整性和一致性，但各事务间冲突而死锁的机会大大增加，大大影响了系统性能。 （6）使用绑定连接,&nbsp; 绑定连接允许两个或多个事务连接共享事务和锁，而且任何一个事务连接要申请锁如同另外一个事务要申请锁一样，因此可以允许这些事务共享数据而不会有加锁的冲突。&nbsp;&nbsp;&nbsp; </font></p>
<p><font color=#000000>&nbsp;&nbsp;&nbsp; 总之，了解SQL Server的锁机制，掌握数据库锁定方法, 对一个合格的DBA来说是很重要的。</font></p>
</div>
<br>
<img src ="http://www.cppblog.com/ivenher/aggbug/22136.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2007-04-17 16:03 <a href="http://www.cppblog.com/ivenher/articles/22136.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>sqlserver，oracle和DB2的临时表概述 </title><link>http://www.cppblog.com/ivenher/articles/22133.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Tue, 17 Apr 2007 07:40:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/22133.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/22133.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/22133.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/22133.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/22133.html</trackback:ping><description><![CDATA[<p><strong><span twffan="done"><font size=2><font face=Verdana>MS SQLSERVER</font></font></span></strong></p>
<p><font size=2><font face=Verdana><span twffan="done">SQL Server </span><span twffan="done">支持临时表。临时表就是那些名称以井号<span twffan="done"> (#) </span>开头的表。如果当用户断开连接时没有除去临时表，<span twffan="done">SQL Server </span>将自动除去临时表。临时表不存储在当前数据库内，而是存储在系统数据库 <strong><span twffan="done">tempdb </span></strong>内。</span></font></font></p>
<p><span twffan="done"><font size=2><font face=Verdana>临时表有两种类型： </font></font></span></p>
<p><font size=2><font face=Verdana><strong><span twffan="done">本地临时表</span></strong><span twffan="done">：本地临时表的名称以单个数字符号<span twffan="done"> (#) </span>打头；它们仅对当前的用户连接是可见的；当用户从<span twffan="done"> Microsoft SQL Server 2000 </span>实例断开连接时被删除。</span></font></font></p>
<p><font size=2><font face=Verdana><strong><span twffan="done">全局临时表</span></strong><span twffan="done">：全局临时表的名称以数学符号<span twffan="done"> (##) </span>打头，创建后对任何用户都是可见的。如果在创建全局临时表的连接断开前没有显式地除去这些表，那么只要所有其它任务停止引用它们，这些表即被除去。当创建全局临时表的连接断开后，新的任务不能再引用它们。当前的语句一执行完，任务与表之间的关联即被除去；因此通常情况下，只要创建全局临时表的连接断开，全局临时表即被除去。</span></font></font></p>
<p><span twffan="done"><font size=2><font face=Verdana>例如，如果创建名为 <strong><span twffan="done">employees </span></strong>的表，则任何人只要在数据库中有使用该表的安全权限就可以使用该表，除非它已删除。如果创建名为 <strong><span twffan="done">#employees </span></strong>的本地临时表，只有您能对该表执行操作且在断开连接时该表删除。如果创建名为 <strong><span twffan="done">##employees </span></strong>的全局临时表，数据表中的任何用户均可对该表执行操作。如果该表在您创建后没有其他用户使用，则当您断开连接时该表删除。如果该表在您创建后有其他用户使用，则<span twffan="done"> SQL Server</span>在所有用户断开连接后删除该表。</font></font></span></p>
<p><font face=Verdana size=2>现在，临时表的许多传统用途可由具有 <strong><span twffan="done">table</span></strong><span twffan="done"> </span>数据类型的变量替换。</font></p>
<p><span twffan="done"><font face=Verdana size=2>&nbsp;</font></span></p>
<p><strong><span twffan="done"><font size=2><font face=Verdana>ORACLE</font></font></span></strong></p>
<p><font size=2><font face=Verdana><span twffan="done">Oracle</span><span twffan="done">支持临时表。临时表用来保存事务或会话期间的中间结果。在临时表中保存的数据只有对当前会话是可见的，任何会话都不能看到其他会话的数据，即使在当前会话<span twffan="done">COMMIT</span>数据以后也是不可见的。多用户并行不是问题，一个会话从来不阻塞另一个会话使用临时表。即使锁定临时表，一个会话也不会阻塞其他会话使用临时表。临时表比正常表产生的<span twffan="done">REDO</span>少得多，然而，由于临时表必须产生包含数据的<span twffan="done">UNDO</span>信息，所以会产生一定数量的<span twffan="done">REDO</span>日志。</span></font></font></p>
<p><span twffan="done"><font size=2><font face=Verdana>临时表将从用户临时表空间中分配空间，或者如果从有定义权的程序中访问，将使用程序所有者的临时表空间。全局临时表实际上只是表本身的模板。创建临时表的行为不包括存储空间的分配，也不包括<span twffan="done">INITIAL</span>的分配。因此，在运行时当一个会话首先将数据放到临时表中时，这时将创建这个会话的临时段。由于每个会话获取自己的临时段，每个用户可能在不同的表空间中为临时表分配空间。<span twffan="done">USER1</span>的<span twffan="done">default</span>临时表空间为<span twffan="done">TEMP1</span>，他的临时表将从<span twffan="done">TEMP1</span>中分配空间，<span twffan="done">USER2</span>的<span twffan="done">default</span>临时表空间为<span twffan="done">TEMP2</span>，他的临时表将从<span twffan="done">TEMP2</span>中分配空间。</font></font></span></p>
<p><span twffan="done"><font size=2><font face=Verdana>临时表在每个数据库中只需创建一次，不必在每个存储过程中创建。临时表总是存在的，除非手动的删除他。临时表作为对象存在数据字典中，并且总是保持为空，直到有会话在其中放入数据。<span twffan="done">Oracle</span>允许创建基于临时表的视图和存储过程。</font></font></span></p>
<p><span twffan="done"><font size=2><font face=Verdana>临时表可以是以会话为基础的，也可以是以事务为基础的。<span twffan="done">ON COMMIT PRESERVE ROWS</span>子句使临时表成为基于会话的模式。行将留在此表中，直到会话断开或通过<span twffan="done">DELETE</span>或<span twffan="done">TRUNCATE</span>从物理上删除这些行。<span twffan="done">ON COMMIT DELETE ROWS</span>子句使临时表成为基于事务的模式。当会话提交后，行消失。这个临时表的自动清除过程不会有额外的开销。</font></font></span></p>
<p><span twffan="done"><font size=2><font face=Verdana>在<span twffan="done">oracle</span>中，应用程序需要的临时表应该在程序安装时创建，而不是在程序运行时创建。（这是与<span twffan="done">ms sqlserver</span>或<span twffan="done">sybase</span>的使用的不同）</font></font></span></p>
<p><span twffan="done"><font size=2><font face=Verdana>在任何数据库中，临时表的一个缺点是：事实上优化器在临时表中没有真正的统计功能。然而，在<span twffan="done">oracle</span>中，一系列较好的统计猜测可以通过<span twffan="done">DBMS_STATS</span>包在临时表中设置。</font></font></span></p>
<p><span twffan="done"><font face=Verdana size=2>&nbsp;</font></span></p>
<p><strong><span twffan="done"><font size=2><font face=Verdana>DB2</font></font></span></strong></p>
<p align=left><font size=2><font face=Verdana><span twffan="done">可使用</span><span twffan="done"> DECLARE GLOBAL TEMPORARY TABLE </span><span twffan="done">语句来定义临时表。</span><span twffan="done">DB2</span><span twffan="done">的临时表是基于会话的，且在会话之间是隔离的。当会话结束时，临时表的数据被删除，临时表被隐式卸下。对临时表的定义不会在</span><span twffan="done">SYSCAT.TABLES</span><span twffan="done">中出现</span></font></font></p>
<p><font size=2><font face=Verdana>下面是定义临时表的一个示例：<span twffan="done"> </span></font></font></p>
<pre><font size=2><font face=Verdana><span twffan="done">&nbsp;&nbsp;</span><span twffan="done"> DECLARE GLOBAL TEMPORARY TABLE gbl_temp</span></font></font></pre>
<pre><font size=2><font face=Verdana><span twffan="done">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span twffan="done"> LIKE empltabl</span></font></font></pre>
<pre><font size=2><font face=Verdana><span twffan="done">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span twffan="done"> ON COMMIT DELETE ROWS</span></font></font></pre>
<pre><font size=2><font face=Verdana><span twffan="done">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span twffan="done"> NOT LOGGED</span></font></font></pre>
<pre><font size=2><font face=Verdana><span twffan="done">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span twffan="done"> IN usr_tbsp</span></font></font></pre>
<p><font size=2><font face=Verdana><span twffan="done">此语句创建一个名为</span> <tt><span twffan="done">gbl_temp</span></tt><span twffan="done"> </span><span twffan="done">的用户临时表。定义此用户临时表</span> <span twffan="done">所使用的列的名称和说明与</span> <tt><span twffan="done">empltabl</span></tt><span twffan="done"> </span><span twffan="done">的列的名称和说明完全相同。隐式定义</span> <span twffan="done">只包括列名、数据类型、可为空特性和列缺省值属性。未定义所有其他列属性，包括唯一约束、外部关键字约束、触发器和索引。执行</span><span twffan="done"> COMMIT </span><span twffan="done">操作时，</span> <span twffan="done">若未对该表打开</span><span twffan="done"> WITH HOLD </span><span twffan="done">游标，则该表中的所有数据都被删除。不记录</span> <span twffan="done">对用户临时表所作的更改。用户临时表被放在指定的用户临时表空间中。此表空间必须存在，否则此表的声明将失败。</span><span twffan="done"> </span></font></font></p>
<p><font size=2><font face=Verdana><span twffan="done">户定义临时表不支持：</span><span twffan="done"> </span></font></font></p>
<ul type=disc>
    <li><font size=2><font face=Verdana><span twffan="done">LOB </span><span twffan="done">类型的列（或基于</span><span twffan="done"> LOB </span><span twffan="done">的单值类型列）</span><span twffan="done"> </span></font></font>
    <li><font size=2><font face=Verdana><span twffan="done">用户定义类型列</span><span twffan="done"> </span></font></font>
    <li><font size=2><font face=Verdana><span twffan="done">LONG VARCHAR </span><span twffan="done">列</span> </font></font></li>
</ul>
<img src ="http://www.cppblog.com/ivenher/aggbug/22133.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2007-04-17 15:40 <a href="http://www.cppblog.com/ivenher/articles/22133.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE之常用FAQ V1.0 (4)  第四部分、性能调整</title><link>http://www.cppblog.com/ivenher/articles/13153.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 09:26:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13153.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13153.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13153.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13153.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13153.html</trackback:ping><description><![CDATA[
		<span class="tpc_content" twffan="done">
				<b>第四部分、性能调整</b>
				<br />
				<font color="red">[Q]如果设置自动跟踪</font>
				<br />[A]用system登录<br />执行$ORACLE_HOME/rdbms/admin/utlxplan.sql创建计划表<br />执行$ORACLE_HOME/sqlplus/admin/plustrce.sql创建plustrace角色<br />如果想计划表让每个用户都能使用，则<br />SQL&gt;create public synonym plan_table for plan_table;<br />SQL&gt; grant all on plan_table to public;<br />如果想让自动跟踪的角色让每个用户都能使用，则<br />SQL&gt; grant plustrace to public;<br />通过如下语句开启/停止跟踪<br />SET AUTOTRACE ON |OFF <br />| ON EXPLAIN | ON STATISTICS | TRACEONLY | TRACEONLY EXPLAIN<br /><font color="red">[Q]如果跟踪自己的会话或者是别人的会话</font><br />[A]跟踪自己的会话很简单<br />Alter session set sql_trace true|false<br />Or<br />Exec dbms_session.set_sql_trace(TRUE);<br />如果跟踪别人的会话，需要调用一个包<br />exec dbms_system.set_sql_trace_in_session(sid,serial#,true|false)<br />跟踪的信息在user_dump_dest 目录下可以找到或通过如下脚本获得文件名称（适用于Win环境，如果是unix需要做一定修改）<br />SELECT p1.value||'\'||p2.value||'_ora_'||p.spid||'.ora' filename<br />FROM<br />v$process p,<br />v$session s,<br />v$parameter p1,<br />v$parameter p2<br />WHERE p1.name = 'user_dump_dest'<br />AND p2.name = 'db_name'<br />AND p.addr = s.paddr<br />AND s.audsid = USERENV ('SESSIONID')<br />最后，可以通过Tkprof来解析跟踪文件，如<br />Tkprof 原文件 目标文件 sys=n<br /><font color="red">[Q]怎么设置整个数据库系统跟踪</font><br />[A]其实文档上的alter system set sql_trace=true是不成功的<br />但是可以通过设置事件来完成这个工作，作用相等<br />alter system set events<br />'10046 trace name context forever,level 1';<br />如果关闭跟踪，可以用如下语句<br />alter system set events<br />'10046 trace name context off';<br />其中的level 1与上面的8都是跟踪级别<br />level 1：跟踪SQL语句，等于sql_trace=true<br />level 4：包括变量的详细信息<br />level 8：包括等待事件<br />level 12：包括绑定变量与等待事件<br /><font color="red">[Q]怎么样根据OS进程快速获得DB进程信息与正在执行的语句</font><br />[A]有些时候，我们在OS上操作，象TOP之后我们得到的OS进程，怎么快速根据OS信息获得DB信息呢？<br />我们可以编写如下脚本：<br />$more whoit.sh<br />#!/bin/sh<br />sqlplus /nolog 100,cascade=&gt; TRUE);<br />dbms_stats.gather_table_stats(User,TableName,degree =&gt; 4,cascade =&gt; true);<br />这是对命令与工具包的一些总结<br />1、对于分区表，建议使用DBMS_STATS，而不是使用Analyze语句。 <br />a) 可以并行进行，对多个用户，多个Table <br />b) 可以得到整个分区表的数据和单个分区的数据。 <br />c) 可以在不同级别上Compute Statistics：单个分区，子分区，全表，所有分区 <br />d) 可以倒出统计信息 <br />e) 可以用户自动收集统计信息 <br />2、DBMS_STATS的缺点 <br />a) 不能Validate Structure <br />b) 不能收集CHAINED ROWS, 不能收集CLUSTER TABLE的信息，这两个仍旧需要使用Analyze语句。 <br />c) DBMS_STATS 默认不对索引进行Analyze，因为默认Cascade是False，需要手工指定为True <br />3、对于oracle 9里面的External Table，Analyze不能使用，只能使用DBMS_STATS来收集信息。<br /><font color="red">[Q]怎么样快速重整索引</font><br />[A]通过rebuild语句，可以快速重整或移动索引到别的表空间<br />rebuild有重建整个索引数的功能，可以在不删除原始索引的情况下改变索引的存储参数<br />语法为<br />alter index index_name rebuild tablespace ts_name<br />storage(……);<br />如果要快速重建整个用户下的索引，可以用如下脚本，当然，需要根据你自己的情况做相应修改<br />SQL&gt; set heading off<br />SQL&gt; set feedback off<br />SQL&gt; spool d:\index.sql<br />SQL&gt; SELECT 'alter index ' || index_name || ' rebuild '<br />||'tablespace INDEXES storage(initial 256K next 256K pctincrease 0);'<br />FROM all_indexes<br />WHERE ( tablespace_name != 'INDEXES'<br />OR next_extent != ( 256 * 1024 )<br />)<br />AND owner = USER<br />SQL&gt;spool off<br />另外一个合并索引的语句是<br />alter index index_name coalesce，这个语句仅仅是合并索引中同一级的leaf block<br />消耗不大，对于有些索引中存在大量空间浪费的情况下，有一些作用。<br /><font color="red">[Q]如何使用Hint提示</font><br />[A] 在select/delete/update后写/*+ hint */<br />如 select /*+ index(TABLE_NAME INDEX_NAME) */ col1...<br />注意/*和+之间不能有空格<br />如用hint指定使用某个索引<br />select /*+ index(cbotab) */ col1 from cbotab;<br />select /*+ index(cbotab cbotab1) */ col1 from cbotab;<br />select /*+ index(a cbotab1) */ col1 from cbotab a;<br />其中<br />TABLE_NAME是必须要写的，且如果在查询中使用了表的别名，在hint也要用表的别名来代替表名;<br />INDEX_NAME可以不必写，Oracle会根据统计值选一个索引;<br />如果索引名或表名写错了，那这个hint就会被忽略;<br /><font color="red">[Q]怎么样快速复制表或者是插入数据</font><br />[A]快速复制表可以指定Nologging选项<br />如：Create table t1 nologging <br />as select * from t2;<br />快速插入数据可以指定append提示，但是需要注意<br />noarchivelog模式下，默认用了append就是nologging模式的。 <br />在archivelog下，需要把表设置程Nologging模式。<br />如insert /*+ append */ into t1 <br />select * from t2<br />注意：如果在9i环境中并设置了FORCE LOGGING，则以上操作是无效的，并不会加快，当然，可以通过如下语句设置为NO FORCE LOGGING。<br />Alter database no force logging;<br />是否开启了FORCE LOGGING，可以用如下语句查看<br />SQL&gt; select force_logging from v$database;<br /><font color="red">[Q]怎么避免使用特定索引</font><br />[A]在很多时候，Oracle会错误的使用索引而导致效率的明显下降，我们可以使用一点点技巧而避免使用不该使用的索引，如：<br />表test,有字段a,b,c,d，在a,b,c上建立联合索引inx_a(a,b,c)，在b上单独建立了一个索引Inx_b(b)。<br />在正常情况下，where a=? and b=? and c=?会用到索引inx_a，<br />where b=?会用到索引inx_b<br />但是，where a=? and b=? and c=? group by b会用到哪个索引呢？在分析数据不正确（很长时间没有分析）或根本没有分析数据的情况下，oracle往往会使用索引inx_b。通过执行计划的分析，这个索引的使用，将大大耗费查询时间。<br />当然，我们可以通过如下的技巧避免使用inx_b，而使用inx_a。<br />where a=? and b=? and c=? group by b||'' --如果b是字符<br />where a=? and b=? and c=? group by b+0 --如果b是数字<br />通过这样简单的改变，往往可以是查询时间提交很多倍<br />当然，我们也可以使用no_index提示，相信很多人没有用过，也是一个不错的方法：<br />select /*+ no_index(t,inx_b) */ * from test t<br />where a=? and b=? and c=? group by b<br /><font color="red">[Q]Oracle什么时候会使用跳跃式索引扫描</font><br />[A]这是9i的一个新特性跳跃式索引扫描(Index Skip Scan).<br />例如表有索引index(a,b,c)，当查询条件为<br />where b=?的时候，可能会使用到索引index(a,b,c)<br />如，执行计划中出现如下计划：<br />INDEX (SKIP SCAN) OF 'TEST_IDX' (NON-UNIQUE)<br />Oracle的优化器(这里指的是CBO)能对查询应用Index Skip Scans至少要有几个条件:<br />1 优化器认为是合适的。<br />2 索引中的前导列的唯一值的数量能满足一定的条件（如重复值很多）。<br />3 优化器要知道前导列的值分布(通过分析/统计表得到)。<br />4 合适的SQL语句<br />等。<br /><font color="red">[Q]怎么样创建使用虚拟索引</font><br />[A]可以使用nosegment选项，如<br />create index virtual_index_name on table_name(col_name) nosegment;<br />如果在哪个session需要测试虚拟索引，可以利用隐含参数来处理<br />alter session set "_use_nosegment_indexes" = true;<br />就可以利用explain plan for select ……来看虚拟索引的效果<br />利用@$ORACLE_HOME/rdbms/admin/utlxpls查看执行计划<br />最后，根据需要，我们可以删除虚拟索引，如普通索引一样<br />drop index virtual_index_name;<br />注意：虚拟索引并不是物理存在的，所以虚拟索引并不等同于物理索引，不要用自动跟踪去测试虚拟索引，因为那是实际执行的效果，是用不到虚拟索引的。<br /><font color="red">[Q]怎样监控无用的索引</font><br />[A]Oracle 9i以上，可以监控索引的使用情况，如果一段时间内没有使用的索引，一般就是无用的索引<br />语法为：<br />开始监控：alter index index_name monitoring usage;<br />检查使用状态：select * from v$object_usage;<br />停止监控：alter index index_name nomonitoring usage;<br />当然，如果想监控整个用户下的索引，可以采用如下的脚本：<br />set heading off<br />set echo off<br />set feedback off<br />set pages 10000<br />spool start_index_monitor.sql<br />SELECT 'alter index '||owner||'.'||index_name||' monitoring usage;'<br />FROM dba_indexes<br />WHERE owner = USER; <br />spool off <br />set heading on<br />set echo on<br />set feedback on<br />------------------------------------------------<br />set heading off<br />set echo off<br />set feedback off<br />set pages 10000<br />spool stop_index_monitor.sql<br />SELECT 'alter index '||owner||'.'||index_name||' nomonitoring usage;'<br />FROM dba_indexes<br />WHERE owner = USER; <br />spool off <br />set heading on<br />set echo on<br />set feedback on<br /><font color="red">[Q]怎么样能固定我的执行计划</font><br />[A]可以使用OUTLINE来固定SQL语句的执行计划<br />用如下语句可以创建一个OUTLINE<br />Create oe replace outline OutLn_Name on<br />Select Col1,Col2 from Table<br />where ……<br />如果要删除Outline，可以采用<br />Drop Outline OutLn_Name;<br />对于已经创建了的OutLine，存放在OUTLN用户的OL$HINTS表下面<br />对于有些语句，你可以使用update outln.ol$hints来更新outline<br />如update outln.ol$hints(ol_name,'TEST1','TEST2','TEST2','TEST1)<br />where ol_name in ('TEST1','TEST2');<br />这样，你就把Test1 OUTLINE与Test2 OUTLINE互换了<br />如果想利用已经存在的OUTLINE，需要设置以下参数<br />Alter system/session set Query_rewrite_enabled = true<br />Alter system/session set use_stored_outlines = true<br /><font color="red">[Q]v$sysstat中的class分别代表什么</font><br />[A]统计类别<br />1 代表事例活动<br />2 代表Redo buffer活动<br />4 代表锁<br />8 代表数据缓冲活动<br />16 代表OS活动<br />32 代表并行活动<br />64 代表表访问<br />128 代表调试信息<br /><font color="red">[Q]怎么杀掉特定的数据库会话</font><br />[A] Alter system kill session 'sid,serial#';<br />或者<br />alter system disconnect session 'sid,serial#' immediate;<br />在win上，还可以采用oracle提供的orakill杀掉一个线程（其实就是一个Oracle进程）<br />在Linux/Unix上，可以直接利用kill杀掉数据库进程对应的OS进程<br /><font color="red">[Q]怎么快速查找锁与锁等待</font><br />[A]数据库的锁是比较耗费资源的，特别是发生锁等待的时候，我们必须找到发生等待的锁，有可能的话，杀掉该进程。<br />这个语句将查找到数据库中所有的DML语句产生的锁，还可以发现，任何DML语句其实产生了两个锁，一个是表锁，一个是行锁。<br />可以通过alter system kill session ‘sid,serial#’来杀掉会话<br />SELECT /*+ rule */ s.username,<br />decode(l.type,'TM','TABLE LOCK',<br />'TX','ROW LOCK',<br />NULL) LOCK_LEVEL,<br />o.owner,o.object_name,o.object_type,<br />s.sid,s.serial#,s.terminal,s.machine,s.program,s.osuser<br />FROM v$session s,v$lock l,dba_objects o<br />WHERE l.sid = s.sid<br />AND l.id1 = o.object_id(+)<br />AND s.username is NOT NULL<br />如果发生了锁等待，我们可能更想知道是谁锁了表而引起谁的等待<br />以下的语句可以查询到谁锁了表，而谁在等待。<br />SELECT /*+ rule */ lpad(' ',decode(l.xidusn ,0,3,0))||l.oracle_username User_name,<br />o.owner,o.object_name,o.object_type,s.sid,s.serial#<br />FROM v$locked_object l,dba_objects o,v$session s<br />WHERE l.object_id=o.object_id<br />AND l.session_id=s.sid<br />ORDER BY o.object_id,xidusn DESC<br />以上查询结果是一个树状结构，如果有子节点，则表示有等待发生。如果想知道锁用了哪个回滚段，还可以关联到V$rollname，其中xidusn就是回滚段的USN<br /><font color="red">[Q] 如何有效的删除一个大表(extent数很多的表)</font><br />[A] 一个有很多(100k)extent的表，如果只是简单地用drop table的话，会很大量消耗CPU（Oracle要对fet$、uet$数据字典进行操作），可能会用上几天的时间，较好的方法是分多次删除extent，以减轻这种消耗：<br />1. truncate table big-table reuse storage;<br />2. alter table big-table deallocate unused keep 2000m ( 原来大小的n-1/n);<br />3. alter table big-table deallocate unused keep 1500m ;<br />....<br />4. drop table big-table;<br /><font color="red">[Q]如何收缩临时数据文件的大小</font><br />[A]9i以下版本采用<br />ALTER DATABASE DATAFILE 'file name' RESIZE 100M类似的语句<br />9i以上版本采用<br />ALTER DATABASE TEMPFILE 'file name' RESIZE 100M<br />注意，临时数据文件在使用时，一般不能收缩，除非关闭数据库或断开所有会话，停止对临时数据文件的使用。<br /><font color="red">[Q]怎么清理临时段</font><br />[A]可以使用如下办法<br />1、 使用如下语句查看一下认谁在用临时段<br />SELECT username,sid,serial#,sql_address,machine,program,<br />tablespace,segtype, contents <br />FROM v$session se,v$sort_usage su<br />WHERE se.saddr=su.session_addr <br />2、 那些正在使用临时段的进程<br />SQL&gt;Alter system kill session 'sid,serial#';<br />3、把TEMP表空间回缩一下<br />SQL&gt;Alter tablespace TEMP coalesce;<br />还可以使用诊断事件<br />1、 确定TEMP表空间的ts#<br />SQL&gt; select ts#, name FROM v$tablespace;<br />TS# NAME <br />----------------------- <br />0 SYSYEM <br />1 RBS <br />2 USERS <br />3* TEMP <br />……<br />2、 执行清理操作<br />alter session set events 'immediate trace name DROP_SEGMENTS level TS#+1'<br />说明： <br />temp表空间的TS# 为 3*, So TS#+ 1= 4<br />如果想清除所有表空间的临时段，则 <br />TS# = 2147483647<br /><font color="red">[Q]怎么样dump数据库内部结构，如上面显示的控制文件的结构</font><br />[A]常见的有<br />1、分析数据文件块，转储数据文件n的块m<br />alter system dump datafile n block m<br />2、分析日志文件<br />alter system dump logfile logfilename;<br />3、分析控制文件的内容<br />alter session set events 'immediate trace name CONTROLF level 10'<br />4、分析所有数据文件头<br />alter session set events 'immediate trace name FILE_HDRS level 10'<br />5、分析日志文件头<br />alter session set events 'immediate trace name REDOHDR level 10'<br />6、分析系统状态，最好每10分钟一次，做三次对比<br />alter session set events 'immediate trace name SYSTEMSTATE level 10'<br />7、分析进程状态<br />alter session set events 'immediate trace name PROCESSSTATE level 10'<br />8、分析Library Cache的详细情况<br />alter session set events 'immediate trace name library_cache level 10'<br /><font color="red">[Q]如何获得所有的事件代码</font><br />[A] 事件代码范围一般从10000 to 10999，以下列出了这个范围的事件代码与信息<br />SET SERVEROUTPUT ON<br />DECLARE <br />err_msg VARCHAR2(120);<br />BEGIN<br />dbms_output.enable (1000000);<br />FOR err_num IN 10000..10999<br />LOOP<br />err_msg := SQLERRM (-err_num);<br />IF err_msg NOT LIKE '%Message '||err_num||' not found%' THEN<br />dbms_output.put_line (err_msg);<br />END IF;<br />END LOOP;<br />END;<br />/<br />在Unix系统上，事件信息放在一个文本文件里 <br />$ORACLE_HOME/rdbms/mesg/oraus.msg<br />可以用如下脚本查看事件信息 <br />event=10000<br />while [ $event -ne 10999 ]<br />do<br />event=`expr $event + 1`<br />oerr ora $event<br />done<br />对于已经确保的/正在跟踪的事件，可以用如下脚本获得<br />SET SERVEROUTPUT ON<br />DECLARE<br />l_level NUMBER;<br />BEGIN<br />FOR l_event IN 10000..10999<br />LOOP<br />dbms_system.read_ev (l_event,l_level);<br />IF l_level &gt; 0 THEN<br />dbms_output.put_line ('Event '||TO_CHAR (l_event)||<br />' is set at level '||TO_CHAR (l_level));<br />END IF;<br />END LOOP;<br />END;<br />/<br /><font color="red">[Q]什么是STATSPACK，我怎么使用它？</font><br />[A]Statspack是Oracle 8i以上提供的一个非常好的性能监控与诊断工具，基本上全部包含了BSTAT/ESTAT的功能，更多的信息<br />可以参考附带文档$ORACLE_HOME/rdbms/admin/spdoc.txt。 <br />安装Statspack: <br />cd $ORACLE_HOME/rdbms/admin<br />sqlplus "/ as sysdba" @spdrop.sql -- 卸载，第一次可以不需要<br />sqlplus "/ as sysdba" @spcreate.sql -- 需要根据提示输入表空间名<br />使用Statspack: <br />sqlplus perfstat/perfstat<br />exec statspack.snap; -- 进行信息收集统计，每次运行都将产生一个快照号<br />-- 获得快照号，必须要有两个以上的快照，才能生成报表<br />select SNAP_ID, SNAP_TIME from STATS$SNAPSHOT; <br />@spreport.sql -- 输入需要查看的开始快照号与结束快照号<br />其他相关脚本s: <br />spauto.sql - 利用dbms_job提交一个作业，自动的进行STATPACK的信息收集统计 <br />sppurge.sql - 清除一段范围内的统计信息，需要提供开始快照与结束快照号<br />sptrunc.sql - 清除(truncate)所有统计信息</span>
		<br />
		<!---->
		<!---->
		<!---->
		<br />
<img src ="http://www.cppblog.com/ivenher/aggbug/13153.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 17:26 <a href="http://www.cppblog.com/ivenher/articles/13153.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE之常用FAQ V1.0 (5)  第五部分、ORACLE网络与安全</title><link>http://www.cppblog.com/ivenher/articles/13154.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 09:26:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13154.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13154.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13154.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13154.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13154.html</trackback:ping><description><![CDATA[
		<span class="tpc_content" twffan="done">
				<b>第五部分、ORACLE网络与安全</b>
				<br />
				<font color="red">[Q]如何限定特定IP访问数据库</font>
				<br />[A]可以利用登录触发器、cmgw或者是在$OREACLE_HOME/network/admin下新增一个protocol.ora文件（有些os可能是. protocol.ora），9i可以直接修改sqlnet.ora：<br />增加如下内容：<br />tcp.validnode_checking=yes<br />#允许访问的ip<br />tcp.inited_nodes=(ip1,ip2,……)<br />#不允许访问的ip<br />tcp.excluded_nodes=(ip1,ip2,……)<br /><font color="red">[Q]如何穿过防火墙连接数据库</font><br />[A]这个问题只会在WIN平台出现，UNIX平台会自动解决。<br />解决方法：<br />在服务器端的SQLNET.ORA应类似<br />SQLNET.AUTHENTICATION_SERVICES= (NTS) <br />NAMES.DIRECTORY_PATH= (TNSNAMES, ONAMES, HOSTNAME) <br />TRACE_LEVEL_CLIENT = 16 <br />注册表的HOME0加[HKEY_LOCAL_MACHINE] <br />USE_SHARED_SOCKET=TRUE<br /><font color="red">[Q]如何利用hostname方式连接数据库</font><br />host name方式只支持tcp/ip协议的小局域网<br />修改listener.ora中的如下信息<br />(SID_DESC =<br />(GLOBAL_DBNAME = ur_hostname) --你的机器名<br />(ORACLE_HOME = E:\oracle\ora92) --oracle home<br />(SID_NAME = orcl) --sid name<br />)<br />然后在客户端<br />的sqlnet.ora中，确保有<br />NAMES.DIRECTORY_PATH= (HOSTNAME)<br />你就可以利用数据库服务器的名称访问数据库了<br /><font color="red">[Q]dbms_repcat_admin能带来什么安全隐患</font><br />[A]如果一个用户能执行dbms_repcat_admin包，将获得极大的系统权限。<br />以下情况可能获得该包的执行权限：<br />1、在sys下grant execute on dbms_repcat_admin to public[|user_name]<br />2、用户拥有execute any procedure特权（仅限于9i以下，9i必须显示授权）<br />如果用户通过执行如下语句：<br />exec sys.dbms_repcat_admin.grant_admin_any_schema('user_name');<br />该用户将获得极大的系统特权<br />可以从user_sys_privs中获得详细信息<br /><font color="red">[Q]在不知道用户密码的时候，怎么样跳转到另外一个用户执行操作后并不影响该用户?</font><br />[A]我们通过如下的方法，可以安全使用该用户，然后再跳转回来，在某些时候比较有用<br />需要Alter user权限或DBA权限：<br />SQL&gt; select password from dba_users where username='SCOTT';<br />PASSWORD<br />-----------------------------<br />F894844C34402B67<br />SQL&gt; alter user scott identified by lion;<br />User altered.<br />SQL&gt; connect scott/lion<br />Connected.<br />REM Do whatever you like...<br />SQL&gt; connect system/manager<br />Connected.<br />SQL&gt; alter user scott identified by values 'F894844C34402B67';<br />User altered.<br />SQL&gt; connect scott/tiger<br />Connected.<br /><font color="red">[Q]如何加固你的数据库</font><br />[A]要注意以下方面<br />1. 修改sys, system的口令。 <br />2. Lock，修改，删除默认用户： dbsnmp,ctxsys等。 <br />3. 把REMOTE_OS_AUTHENT改成False，防止远程机器直接登陆。 <br />4. 把O7_DICTIONARY_ACCESSIBILITY改成False。 <br />5. 把一些权限从PUBLIC Role取消掉。 <br />6. 检查数据库的数据文件的安全性。不要设置成666之类的。检查其他dba 用户。 <br />7. 把一些不需要的服务（比如ftp, nfs等关闭掉） <br />8. 限制数据库主机上面的用户数量。 <br />9. 定期检查Metalink/OTN上面的security Alert。比如：<br /><a href="http://otn.oracle.com/deploy/security/alerts.htm" target="_blank"><font color="#003366">http://otn.oracle.com/deploy/security/alerts.htm</font></a><br /><br />10. 把你的数据库与应用放在一个单独的子网中，要不然你的用户密码很容易被sniffer去。或者采用advance security，对用户登录加密。 <br />11. 限止只有某些ip才能访问你的数据库。 <br />12. lsnrctl 要加密码，要不然别人很容易从外面关掉你的listener。 <br />13. 如果可能，不要使用默认1521端口<br /><font color="red">[Q]如何检查用户是否用了默认密码</font><br /><br />[A]如果使用默认密码，很可能就对你的数据库造成一定的安全隐患，那么可以使用如下的查询获得那些用户使用默认密码<br />select username "User(s) with Default Password!" <br />from dba_users <br />where password in <br />('E066D214D5421CCC', -- dbsnmp <br />'24ABAB8B06281B4C', -- ctxsys <br />'72979A94BAD2AF80', -- mdsys <br />'C252E8FA117AF049', -- odm <br />'A7A32CD03D3CE8D5', -- odm_mtr <br />'88A2B2C183431F00', -- ordplugins <br />'7EFA02EC7EA6B86F', -- ordsys <br />'4A3BA55E08595C81', -- outln <br />'F894844C34402B67', -- scott <br />'3F9FBD883D787341', -- wk_proxy <br />'79DF7A1BD138CF11', -- wk_sys <br />'7C9BA362F8314299', -- wmsys <br />'88D8364765FCE6AF', -- xdb <br />'F9DA8977092B7B81', -- tracesvr <br />'9300C0977D7DC75E', -- oas_public <br />'A97282CE3D94E29E', -- websys <br />'AC9700FD3F1410EB', -- lbacsys <br />'E7B5D92911C831E1', -- rman <br />'AC98877DE1297365', -- perfstat <br />'66F4EF5650C20355', -- exfsys <br />'84B8CBCA4D477FA3', -- si_informtn_schema <br />'D4C5016086B2DC6A', -- sys <br />'D4DF7931AB130E37') -- system <br />/<br /><font color="red">[Q]如何修改默认的XDB监听端口</font><br /><br />[A] Oracle9i默认的XML DB把HTTP的默认端口设为8080，这是一个太常用的端口了，很多别的WebServer都会使用这个端口，<br />如果我们安装了它，最好修改一下，避免冲突，如果不使用呢，就最好不要安装<br />提供三种修改的方法<br />1.dbca，选择你的数据库，然后Standard Database Features-&gt;Customize-&gt;Oracle XML DB option，进入这个画面你应该就知道怎么改了。 <br />2.OEM console，在XML Database 的配置里面修改 <br />3.用oracle提供的包： <br />-- 把HTTP/WEBDAV端口从8080改到8081 <br />SQL&gt; call dbms_xdb.cfg_update(updateXML(dbms_xdb.cfg_get(), <br />'/xdbconfig/sysconfig/protocolconfig/httpconfig/http-port/text()',8081)) <br />/ <br />-- 把FTP端口从2100改到2111 <br />SQL&gt; call dbms_xdb.cfg_update(updateXML(dbms_xdb.cfg_get(), <br />'/xdbconfig/sysconfig/protocolconfig/ftpconfig/ftp-port/text()',2111)) <br />/ <br />SQL&gt; commit; <br />SQL&gt; exec dbms_xdb.cfg_refresh; <br />-- 检查修改是否已经成功 <br />SQL&gt; select dbms_xdb.cfg_get from dual;<br /><font color="red">[Q]怎么捕获用户登录信息，如SID，IP地址等</font><br />[A]可以利用登录触发器，如<br />CREATE OR REPLACE TRIGGER tr_login_record<br />AFTER logon ON DATABASE<br />DECLARE<br />miUserSid NUMBER;<br />mtSession v$session%ROWTYPE;<br />CURSOR cSession(iiUserSid IN NUMBER) IS<br />SELECT * FROM v$session<br />WHERE sid=iiUserSid;<br />BEGIN<br />SELECT sid INTO miUserSid FROM v$mystat WHERE rownum</span>
		<br />
		<!---->
		<!---->
		<!---->
<img src ="http://www.cppblog.com/ivenher/aggbug/13154.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 17:26 <a href="http://www.cppblog.com/ivenher/articles/13154.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE之常用FAQ V1.0 (2) 第二部分、ORACLE构架体系</title><link>http://www.cppblog.com/ivenher/articles/13151.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 09:24:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13151.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13151.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13151.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13151.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13151.html</trackback:ping><description><![CDATA[
		<span class="tpc_content" twffan="done">
				<b>第二部分、ORACLE构架体系</b>
				<br />
				<font color="red">[Q]ORACLE的有那些数据类型</font>
				<br />[A]常见的数据类型有<br />CHAR固定长度字符域，最大长度可达2000个字节 <br />NCHAR多字节字符集的固定长度字符域，长度随字符集而定，最多为2000个字符或2000个字节 <br />VARCHAR2可变长度字符域，最大长度可达4000个字符 <br />NVARCHAR2多字节字符集的可变长度字符域，长度随字符集而定，最多为4000个字符或4000个字节 <br />DATE用于存储全部日期的固定长度(7个字节)字符域，时间作为日期的一部分存储其中。除非 <br />通过设置init.ora文件的NLS_DATE_FORMAT参数来取代日期格式，否则查询时，日期以 <br />DD-MON-YY格式表示，如13-APR-99表示1999.4.13 <br />NUMBER可变长度数值列，允许值为0、正数和负数。NUMBER值通常以4个字节或更少的字节存储，最多21字节 <br />LONG可变长度字符域，最大长度可到2GB <br />RAW表示二进制数据的可变长度字符域，最长为2000个字节 <br />LONGRAW表示二进制数据的可变长度字符域，最长为2GB <br />MLSLABEL只用于TrustedOracle，这个数据类型每行使用2至5个字节 <br />BLOB二进制大对象，最大长度为4GB <br />CLOB字符大对象，最大长度为4GB <br />NCLOB多字节字符集的CLOB数据类型，最大长度为4GB <br />BFILE外部二进制文件，大小由操作系统决定 <br />ROWID表示RowID的二进制数据，Oracle8RowID的数值为10个字节，在Oracle7中使用的限定 <br />RowID格式为6个字节 <br />UROWID用于数据寻址的二进制数据，最大长度为4000个字节 <br /><font color="red">[Q]Oracle有哪些常见关键字，不能被用于对象名</font><br />[A]以8i版本为例，一般保留关键字不能用做对象名<br />ACCESS ADD ALL ALTER AND ANY AS ASC AUDIT BETWEEN BY CHAR CHECK CLUSTER COLUMN COMMENT COMPRESS CONNECT CREATE CURRENT DATE DECIMAL DEFAULT DELETE DESC DISTINCT DROP ELSE EXCLUSIVE EXISTS FILE FLOAT FOR FROM GRANT GROUP HAVING IDENTIFIED IMMEDIATE IN INCREMENT INDEX INITIAL INSERT INTEGER INTERSECT INTO IS LEVEL LIKE LOCK LONG MAXEXTENTS MINUS MLSLABEL MODE MODIFY NOAUDIT NOCOMPRESS NOT NOWAIT NULL NUMBER OF OFFLINE ON ONLINE OPTION OR ORDER PCTFREE PRIOR PRIVILEGES PUBLIC RAW RENAME RESOURCE REVOKE ROW ROWID ROWNUM ROWS SELECT SESSION SET SHARE SIZE SMALLINT START SUCCESSFUL SYNONYM SYSDATE TABLE THEN TO TRIGGER UID UNION UNIQUE UPDATE USER VALIDATE VALUES VARCHAR VARCHAR2 VIEW WHENEVER WHERE WITH<br />详细信息可以查看v$reserved_words视图<br /><font color="red">[Q]怎么查看数据库版本</font><br />[A]select * from v$version<br />包含版本信息，核心版本信息，位数信息(32位或64位)等<br />至于位数信息，在linux/unix平台上，可以通过file查看，如<br />file $ORACLE_HOME/bin/oracle<br /><font color="red">[Q]怎么查看数据库参数</font><br />[A]show parameter 参数名<br />如通过show parameter spfile可以查看9i是否使用spfile文件<br />或者select * from v$parameter<br />除了这部分参数，Oracle还有大量隐含参数，可以通过如下语句查看:<br />SELECT NAME <br />,VALUE <br />,decode(isdefault, 'TRUE','Y','N') as "Default" <br />,decode(ISEM,'TRUE','Y','N') as SesMod <br />,decode(ISYM,'IMMEDIATE', 'I', <br />'DEFERRED', 'D', <br />'FALSE', 'N') as SysMod <br />,decode(IMOD,'MODIFIED','U', <br />'SYS_MODIFIED','S','N') as Modified <br />,decode(IADJ,'TRUE','Y','N') as Adjusted <br />,description <br />FROM ( --GV$SYSTEM_PARAMETER <br />SELECT x.inst_id as instance <br />,x.indx+1 <br />,ksppinm as NAME <br />,ksppity <br />,ksppstvl as VALUE <br />,ksppstdf as isdefault <br />,decode(bitand(ksppiflg/256,1),1,'TRUE','FALSE') as ISEM <br />,decode(bitand(ksppiflg/65536,3), <br />1,'IMMEDIATE',2,'DEFERRED','FALSE') as ISYM <br />,decode(bitand(ksppstvf,7),1,'MODIFIED','FALSE') as IMOD <br />,decode(bitand(ksppstvf,2),2,'TRUE','FALSE') as IADJ <br />,ksppdesc as DESCRIPTION <br />FROM x$ksppi x <br />,x$ksppsv y <br />WHERE x.indx = y.indx <br />AND substr(ksppinm,1,1) = '_' <br />AND x.inst_id = USERENV('Instance') <br />) <br />ORDER BY NAME<br /><font color="red">[Q]怎么样查看数据库字符集</font><br />[A]数据库服务器字符集select * from nls_database_parameters，其来源于props$，是表示数据库的字符集。<br />客户端字符集环境select * from nls_instance_parameters,其来源于v$parameter，<br />表示客户端的字符集的设置，可能是参数文件，环境变量或者是注册表<br />会话字符集环境 select * from nls_session_parameters，其来源于v$nls_parameters，表示会话自己的设置，可能是会话的环境变量或者是alter session完成，如果会话没有特殊的设置，将与nls_instance_parameters一致。<br />客户端的字符集要求与服务器一致，才能正确显示数据库的非Ascii字符。如果多个设置存在的时候，alter session&gt;环境变量&gt;注册表&gt;参数文件<br />字符集要求一致，但是语言设置却可以不同，语言设置建议用英文。如字符集是zhs16gbk，则nls_lang可以是American_America.zhs16gbk。<br /><font color="red">[Q]怎么样修改字符集</font><br />[A]8i以上版本可以通过alter database来修改字符集，但也只限于子集到超集，不建议修改props$表，将可能导致严重错误。<br />Startup nomount;<br />Alter database mount exclusive;<br />Alter system enable restricted session;<br />Alter system set job_queue_process=0;<br />Alter database open;<br />Alter database character set zhs16gbk;<br /><font color="red">[Q]怎样建立基于函数索引</font><br />[A]8i以上版本，确保<br />Query_rewrite_enabled=true<br />Query_rewrite_integrity=trusted<br />Compatible=8.1.0以上<br />Create index indexname on table (function(field));<br /><font color="red">[Q]怎么样移动表或表分区</font><br />[A]移动表的语法<br />Alter table tablename move<br />[Tablespace new_name<br />Storage(initial 50M next 50M <br />pctincrease 0 pctfree 10 pctused 50 initrans 2) nologging]<br />移动分区的语法<br />alter table tablename move (partition partname)<br />[update global indexes]<br />之后之后必须重建索引<br />Alter index indexname rebuild<br />如果表有Lob段，那么正常的Alter不能移动Lob段到别的表空间，而仅仅是移动了表段，可以采用如下的方法移动Lob段<br />alter table tablename move <br />lob(lobsegname) store as (tablespace newts);<br /><font color="red">[Q]怎么获得当前的SCN</font><br />[A]9i以下版本<br />select max(ktuxescnw*power(2,32)+ktuxescnb) from x$ktuxe;<br />如果是9i以上版本，还可以通过以下语句获取<br />select dbms_flashback.get_system_change_number from dual;<br /><font color="red">[Q]ROWID的结构与组成</font><br />[A]8以上版本的ROWID组成<br />OOOOOOFFFBBBBBBRRR<br />8以下ROWID组成（也叫受限Rowid）<br />BBBBBBBB.RRRR.FFFF<br />其中，O是对象ID，F是文件ID，B是块ID，R是行ID<br />如果我们查询一个表的ROWID，根据其中块的信息，可以知道该表确切占用了多少个块，进而知道占用了多少数据空间（此数据空间不等于表的分配空间）<br /><font color="red">[Q]怎么样获取对象的DDL语句</font><br />[A]第三方工具就不说了主要说一下9i以上版本的dbms_metadata<br />1、获得单个对象的DDL语句<br />set heading off<br />set echo off<br />set feedback off<br />set pages off<br />set long 90000<br />select dbms_metadata.get_ddl('TABLE','TABLENAME','SCAME') from dual;<br />如果获取整个用户的脚本，可以用如下语句<br />select dbms_metadata.get_ddl('TABLE',u.table_name) from user_tables u;<br />当然，如果是索引，则需要修改相关table到index<br /><font color="red">[Q]如何创建约束的索引在别的表空间上</font><br />[A]1、先创建索引，再创建约束<br />2、利用如下语句创建<br />create table test<br />(c1 number constraint pk_c1_id primary key<br />using index tablespace useridex,<br />c2 varchar2(10)<br />) tablespace userdate;<br /><font color="red">[Q]怎么知道那些表没有建立主键</font><br />[A]一般的情况下，表的主键是必要的，没有主键的表可以说是不符合设计规范的。<br />SELECT table_name<br />FROM User_tables t <br />WHERE NOT EXISTS <br />(SELECT table_name<br />FROM User_constraints c<br />WHERE constraint_type = 'P'<br />AND t.table_name=c.table_name)<br />其它相关数据字典解释<br />user_tables 表<br />user_tab_columns 表的列<br />user_constraints 约束<br />user_cons_columns 约束与列的关系<br />user_indexes 索引<br />user_ind_columns 索引与列的关系<br /><font color="red">[Q]dbms_output提示缓冲区不够，怎么增加</font><br />[A]dbms_output.enable(20000);<br />另外，如果dbms_output的信息不能显示，<br />需要设置<br />set serveroutput on<br /><font color="red">[Q]怎么样修改表的列名</font><br />[A]9i以上版本可以采用rname命令<br />ALTER TABLE UserName.TabName <br />RENAME COLUMN SourceColumn TO DestColumn<br />9i以下版本可以采用create table …… as select * from SourceTable的方式。<br />另外，8i以上可以支持删除列了<br />ALTER TABLE UserName.TabName <br />SET UNUSED (ColumnName) CASCADE CONSTRAINTS<br />ALTER TABLE UserName.TabName <br />DROP (ColumnName) CASCADE CONSTRAINTS<br /><font color="red">[Q]怎么样给sqlplus安装帮助</font><br />[A]SQLPLUS的帮助必须手工安装，shell脚本为$ORACLE_HOME/bin/helpins<br />在安装之前，必须先设置SYSTEM_PASS环境变量，如：<br />$ setenv SYSTEM_PASS SYSTEM/MANAGER <br />$ helpins<br />如果不设置该环境变量，将在运行脚本的时候提示输入环境变量<br />当然，除了shell脚本，还可以利用sql脚本安装，那就不用设置环境变量了，但是，我们必须以system登录。<br />$ sqlplus system/manager <br />SQL&gt; @?/sqlplus/admin/help/helpbld.sql helpus.sql<br />安装之后，你就可以象如下的方法使用帮助了<br />SQL&gt; help index<br /><font color="red">[Q]怎么样快速下载Oracle补丁</font><br />[A]我们先获得下载服务器地址，在http页面上有<br /><a href="ftp://updates.oracle.com/" target="_blank"><font color="#003366">ftp://updates.oracle.com</font></a><br />然后用ftp登录，用户名与密码是metalink的用户名与密码<br />如我们知道了补丁号3095277 (9204的补丁集)，则<br />ftp&gt; cd 3095277 <br />250 Changed directory OK. <br />ftp&gt; ls <br />200 PORT command OK. <br />150 Opening data connection for file listing. <br />p3095277_9204_AIX64-5L.zip <br />p3095277_9204_AIX64.zip <br />……<br />p3095277_9204_WINNT.zip <br />226 Listing complete. Data connection has been closed. <br />ftp: 208 bytes received in 0.02Seconds 13.00Kbytes/sec. <br />ftp&gt; <br />知道了这个信息，我们用用flashget，网络蚂蚁就可以下载了。 <br />添加如下连接 <br /><a href="ftp://updates.oracle.com/3095277/p3095244_9204_AIX64-5L.zip" target="_blank"><font color="#003366">ftp://updates.oracle.com/3095277/p3...04_AIX64-5L.zip</font></a><br />或替换后面的部分为所需要的内容<br />注意，如果是flashget，网络蚂蚁请输入认证用户名及密码，就是你的metalink的用户名与密码！<br /><font color="red">[Q]如何移动数据文件</font><br />[A]1、关闭数据库，利用os拷贝<br />a.shutdown immediate关闭数据库<br />b.在os下拷贝数据文件到新的地点<br />c.Startup mount 启动到mount下<br />d.Alter database rename datafile '老文件' to '新文件';<br />e.Alter database open; 打开数据库<br />2、利用Rman联机操作<br />RMAN&gt; sql "alter database datafile ''file name'' offline";<br />RMAN&gt; run {<br />2&gt; copy datafile 'old file location'<br />3&gt; to 'new file location';<br />4&gt; switch datafile ' old file location'<br />5&gt; to datafilecopy ' new file location';<br />6&gt; }<br />RMAN&gt; sql "alter database datafile ''file name'' online";<br />说明：利用OS拷贝也可以联机操作，不关闭数据库，与rman的步骤一样，利用rman与利用os拷贝的原理一样，在rman中copy是拷贝数据文件，相当于OS的cp，而switch则相当于alter database rename，用来更新控制文件。<br /><font color="red">[Q]如果管理联机日志组与成员</font><br />[A]以下是常见操作，如果在OPA/RAC下注意线程号<br />增加一个日志文件组<br />Alter database add logfile [group n] '文件全名' size 10M;<br />在这个组上增加一个成员<br />Alter database add logfile member '文件全名' to group n;<br />在这个组上删除一个日志成员<br />Alter database drop logfile member '文件全名';<br />删除整个日志组<br />Alter database drop logfile group n;<br /><font color="red">[Q]怎么样计算REDO BLOCK的大小</font><br />[A]计算方法为(redo size + redo wastage) / redo blocks written + 16<br />具体见如下例子<br />SQL&gt; select name ,value from v$sysstat where name like '%redo%'; <br />NAME VALUE <br />---------------------------------------------------------------- ---------- <br />redo synch writes 2 <br />redo synch time 0 <br />redo entries 76 <br />redo size 19412 <br />redo buffer allocation retries 0 <br />redo wastage 5884 <br />redo writer latching time 0 <br />redo writes 22 <br />redo blocks written 51 <br />redo write time 0 <br />redo log space requests 0 <br />redo log space wait time 0 <br />redo log switch interrupts 0 <br />redo ordering marks 0 <br />SQL&gt; select (19412+5884)/51 + 16 '"Redo black(byte)" from dual; <br />Redo black(byte)<br />------------------ <br />512<br /><font color="red">[Q]控制文件包含哪些基本内容</font><br />[A]控制文件主要包含如下条目，可以通过dump控制文件内容看到<br />DATABASE ENTRY <br />CHECKPOINT PROGRESS RECORDS <br />REDO THREAD RECORDS <br />LOG FILE RECORDS <br />DATA FILE RECORDS <br />TEMP FILE RECORDS <br />TABLESPACE RECORDS <br />LOG FILE HISTORY RECORDS <br />OFFLINE RANGE RECORDS <br />ARCHIVED LOG RECORDS <br />BACKUP SET RECORDS <br />BACKUP PIECE RECORDS <br />BACKUP DATAFILE RECORDS <br />BACKUP LOG RECORDS <br />DATAFILE COPY RECORDS <br />BACKUP DATAFILE CORRUPTION RECORDS <br />DATAFILE COPY CORRUPTION RECORDS <br />DELETION RECORDS <br />PROXY COPY RECORDS<br />INCARNATION RECORDS<br /><font color="red">[Q]如果发现表中有坏块，如何检索其它未坏的数据</font><br />[A]首先需要找到坏块的ID（可以运行dbverify实现），假设为，假定文件编码为。运行下面的查询查找段名： <br />SELECT segment_name,segment_type,extent_id,block_id, blocks <br />from dba_extents t<br />where <br />file_id = <br />AND between block_id and (block_id + blocks - 1) <br />一旦找到坏段名称，若段是一个表，则最好建立一个临时表，存放好的数据。若段是索引，则删除它，再重建。<br />create table good_table <br />as <br />select from bad_table where rowid not in <br />(select rowid <br />from bad_table where substr(rowid,10,6) = )<br />在这里要注意8以前的受限ROWID与现在ROWID的差别。<br />还可以使用诊断事件10231<br />SQL&gt; ALTER SYSTEM SET EVENTS '10231 trace name context forever,level 10';<br />创建一个临时表good_table的表中除坏块的数据都检索出来<br />SQL&gt;CREATE TABLE good_table as select * from bad_table;<br />最后关闭诊断事件<br />SQL&gt; ALTER SYSTEM SET EVENTS '10231 trace name context off ';<br />关于ROWID的结构，还可以参考dbms_rowid.rowid_create函数。<br /><font color="red">[Q]我创建了数据库的所有用户，我可以删除这些用户吗</font><br />[A]ORACLE数据库创建的时候，创建了一系列默认的用户和表空间，以下是他们的列表<br />·SYS/CHANGE_ON_INSTALL or INTERNAL<br />系统用户，数据字典所有者，超级权限所有者(SYSDBA)<br />创建脚本：?/rdbms/admin/sql.bsq and various cat*.sql<br />建议创建后立即修改密码<br />此用户不能被删除<br />·SYSTEM/MANAGER<br />数据库默认管理用户，拥有DBA角色权限<br />创建脚本：?/rdbms/admin/sql.bsq<br />建议创建后立即修改密码<br />此用户不能被删除<br />·OUTLN/OUTLN<br />优化计划的存储大纲用户<br />创建脚本：?/rdbms/admin/sql.bsq<br />建议创建后立即修改密码<br />此用户不能被删除<br />---------------------------------------------------<br />·SCOTT/TIGER, ADAMS/WOOD, JONES/STEEL, CLARK/CLOTH and BLAKE/PAPER.<br />实验、测试用户，含有例表EMP与DEPT<br />创建脚本：?/rdbms/admin/utlsampl.sql<br />可以修改密码<br />用户可以被删除，在产品环境建议删除或锁定<br />·HR/HR (Human Resources), OE/OE (Order Entry), SH/SH (Sales History).<br />实验、测试用户，含有例表EMPLOYEES与DEPARTMENTS<br />创建脚本：?/demo/schema/mksample.sql<br />可以修改密码<br />用户可以被删除，在产品环境建议删除或锁定<br />·DBSNMP/DBSNMP<br />Oracle Intelligent agent<br />创建脚本：?/rdbms/admin/catsnmp.sql, called from catalog.sql<br />可以改变密码--需要放置新密码到snmp_rw.ora文件<br />如果不需要Intelligent Agents，可以删除<br />---------------------------------------------------<br />以下用户都是可选安装用户,如果不需要，就不需要安装<br />·CTXSYS/CTXSYS<br />Oracle interMedia (ConText Cartridge)管理用户<br />创建脚本：?/ctx/admin/dr0csys.sql<br />·TRACESVR/TRACE<br />Oracle Trace server<br />创建脚本：?/rdbms/admin/otrcsvr.sql<br />·ORDPLUGINS/ORDPLUGINS<br />Object Relational Data (ORD) User used by Time Series, etc.<br />创建脚本：?/ord/admin/ordinst.sql<br />·ORDSYS/ORDSYS<br />Object Relational Data (ORD) User used by Time Series, etc<br />创建脚本：?/ord/admin/ordinst.sql<br />·DSSYS/DSSYS<br />Oracle Dynamic Services and Syndication Server<br />创建脚本：?/ds/sql/dssys_init.sql<br />·MDSYS/MDSYS<br />Oracle Spatial administrator user<br />创建脚本：?/ord/admin/ordinst.sql<br />·AURORA$ORB$UNAUTHENTICATED/INVALID<br />Used for users who do not authenticate in Aurora/ORB<br />创建脚本：?/javavm/install/init_orb.sql called from ?/javavm/install/initjvm.sql<br />·PERFSTAT/PERFSTAT<br />Oracle Statistics Package (STATSPACK) that supersedes UTLBSTAT/UTLESTAT<br />创建脚本：?/rdbms/admin/statscre.sql</span>
		<br />
		<!---->
		<!---->
		<!---->
		<br />
<img src ="http://www.cppblog.com/ivenher/aggbug/13151.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 17:24 <a href="http://www.cppblog.com/ivenher/articles/13151.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE之常用FAQ V1.0 (3)   第三部分、备份与恢复</title><link>http://www.cppblog.com/ivenher/articles/13152.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 09:24:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13152.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13152.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13152.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13152.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13152.html</trackback:ping><description><![CDATA[
		<span class="tpc_content" twffan="done">
				<b>第三部分、备份与恢复</b>
				<br />
				<font color="red">[Q]如何开启/关闭归档</font>
				<br />[A]如果开启归档，请保证log_archive_start=true开启自动归档，否则只能手工归档，如果是关闭了归档，则设置该参数为false<br />注意：如果是OPS/RAC环境，需要先把parallel_server = true注释掉，然后执行如下步骤，最后用这个参数重新启动<br />1、开启归档<br />a. 关闭数据库shutdown immediate<br />b. startup mount<br />c. alter database archivelog<br />d. alter database opne<br />2、禁止归档<br />a. 关闭数据库shutdown immediate<br />b. startup mount<br />c. alter database noarchivelog<br />d. alter database open<br />归档信息可以通过如下语句查看<br />SQL&gt; archive log list<br />Database log mode Archive Mode<br />Automatic archival Enabled<br />Archive destination E:\oracle\ora92\database\archive<br />Oldest online log sequence 131<br />Next log sequence to archive 133<br />Current log sequence 133<br /><font color="red">[Q]怎样设置定时归档</font><br />[A]9i以上版本，保证归档的最小间隔不超过n秒<br />设置Archive_lag_target = n <br />单位：秒 范围：0~7200<br /><font color="red">[Q]不同版本怎么导出/导入</font><br />[A]导出用低版本，导入用当前版本<br />如果版本跨越太大，需要用到中间版本过渡<br /><font color="red">[Q]不同的字符集之前怎么导数据</font><br />[A]a.前条件是保证导出/导入符合其他字符集标准，如客户环境与数据库字符集一致。<br />b.修改dmp文件的2、3字节为目标数据库的字符集，注意要换成十六进制。<br />参考函数（以下函数中的ID是十进制的）：<br />nls_charset_name 根据字符集ID获得字符集名称<br />nls_charset_id 根据字符集名称获得字符集ID<br /><font color="red">[Q]怎么样备份控制文件</font><br />[A]再线备份为一个二进制的文件<br />alter database backup controlfile to '$BACKUP_DEPT/controlfile.000' [reuse];<br />备份为文本文件方式<br />alter database backup controlfile to trace [resetlogs|noresetlogs]; <br /><font color="red">[Q]控制文件损坏如何恢复</font><br />[A]1、如果是损坏单个控制文件<br />只需要关闭数据库，拷贝一个好的数据文件覆盖掉坏的数据文件即可<br />或者是修改init.ora文件的相关部分<br />2、如果是损失全部控制文件，则需要创建控制文件或从备份恢复<br />创建控制文件的脚本可以通过alter database backup controlfile to trace获取。<br /><font color="red">[Q]怎么样热备份一个表空间</font><br />[A]Alter tablespace 名称 begin backup;<br />host cp 这个表空间的数据文件 目的地;<br />Alter tablespace 名称 end backup;<br />如果是备份多个表空间或整个数据库，只需要一个一个表空间的操作下来就可以了。<br /><font color="red">[Q]怎么快速得到整个数据库的热备脚本</font><br />[A]可以写一段类似的脚本<br />SQL&gt;set serveroutput on<br />begin<br />dbms_output.enable(10000);<br />for bk_ts in (select distinct t.ts#,t.name from v$tablespace t,v$datafile d where t.ts#=d.ts#) loop<br />dbms_output.put_line('--'||bk_ts.name);<br />dbms_output.put_line('alter tablespace '||bk_ts.name||' begin backup;');<br />for bk_file in (select file#,name from v$datafile where ts#=bk_ts.ts#) loop<br />dbms_output.put_line('host cp '||bk_file.name||' $BACKUP_DEPT/');<br />end loop;<br />dbms_output.put_line('alter tablespace '||bk_ts.name||' end backup;');<br />end loop;<br />end;<br />/<br /><font color="red">[Q]丢失一个数据文件，但是没有备份，怎么样打开数据库</font><br />[A]如果没有备份只能是删除这个数据文件了，会导致相应的数据丢失。<br />SQL&gt;startup mount<br />--ARCHIVELOG模式命令<br />SQL&gt;Alter database datafile 'file name' offline;<br />--NOARCHIVELOG模式命令<br />SQL&gt;Alter database datafile 'file name' offline drop;<br />SQLl&gt;Alter database open;<br />注意：该数据文件不能是系统数据文件<br /><font color="red">[Q]丢失一个数据文件，没有备份但是有该数据文件创建以来的归档怎么恢复</font><br />[A]保证如下条件<br />a. 不能是系统数据文件<br />b. 不能丢失控制文件<br />如果满足以上条件，则<br />SQL&gt;startup mount<br />SQL&gt;Alter database create datafile 'file name' as 'file name' size ... reuse;<br />SQL&gt;recover datafile n; -文件号<br />或者<br />SQL&gt;recover datafile 'file name';<br />或者<br />SQL&gt;recover database;<br />SQL&gt;Alter database open;<br /><font color="red">[Q]联机日志损坏如何恢复</font><br />[A]1、如果是非当前日志而且归档，可以使用<br />Alter database clear logfile group n来创建一个新的日志文件<br />如果该日志还没有归档，则需要用<br />Alter database clear unarchived logfile group n<br />2、如果是当前日志损坏，一般不能clear，则可能意味着丢失数据<br />如果有备份，可以采用备份进行不完全恢复<br />如果没有备份，可能只能用_allow_resetlogs_corruption=true来进行强制恢复了，但是，这样的方法是不建议的，最好在有Oracle support的指导下进行。<br /><font color="red">[Q]怎么样创建RMAN恢复目录</font><br />[A]首先，创建一个数据库用户，一般都是RMAN，并给予recovery_catalog_owner角色权限<br />sqlplus sys<br />SQL&gt; create user rman identified by rman;<br />SQL&gt; alter user rman default tablespace tools temporary tablespace temp;<br />SQL&gt; alter user rman quota unlimited on tools;<br />SQL&gt; grant connect, resource, recovery_catalog_owner to rman;<br />SQL&gt; exit;<br />然后，用这个用户登录，创建恢复目录<br />rman catalog rman/rman<br />RMAN&gt; create catalog tablespace tools;<br />RMAN&gt; exit;<br />最后，你可以在恢复目录注册目标数据库了<br />rman catalog rman/rman target backdba/backdba<br />RMAN&gt; register database;<br /><font color="red">[Q]怎么样在恢复的时候移动数据文件，恢复到别的地点</font><br />[A]给一个RMAN的例子<br />run { <br />set until time 'Jul 01 1999 00:05:00';<br />allocate channel d1 type disk;<br />set newname for datafile '/u04/oracle/prod/sys1prod.dbf'<br />to '/u02/oracle/prod/sys1prod.dbf';<br />set newname for datafile '/u04/oracle/prod/usr1prod.dbf'<br />to '/u02/oracle/prod/usr1prod.dbf';<br />set newname for datafile '/u04/oracle/prod/tmp1prod.dbf'<br />to '/u02/oracle/prod/tmp1prod.dbf';<br />restore controlfile to '/u02/oracle/prod/ctl1prod.ora';<br />replicate controlfile from '/u02/oracle/prod/ctl1prod.ora';<br />restore database;<br />sql "alter database mount";<br />switch datafile all;<br />recover database;<br />sql "alter database open resetlogs";<br />release channel d1;<br />}<br /><font color="red">[Q]怎么从备份片（backuppiece）中恢复(restore)控制文件与数据文件</font><br />[A]可以使用如下方法，在RMAN中恢复备份片的控制文件<br />restore controlfile from backuppiecefile;<br />如果是9i的自动备份，可以采用如下的方法 <br />restore controlfile from autobackup; <br />但是，如果控制文件全部丢失，需要指定DBID，如SET DBID=?<br />自动备份控制文件的默认格式是%F，这个格式的形式为 <br />c-IIIIIIIIII-YYYYMMDD-QQ，其中IIIIIIIIII就是DBID<br />至于恢复(restore)数据文件，oracle 816开始有个包dbms_backup_restore <br />在 nomount 状态下就可以执行，可以读 815甚至之前的备份片，读出来的文件用于恢复 <br />可以在SQLPLUS中运行，如下<br />SQL&gt;startup nomount <br />SQL&gt; DECLARE <br />2 devtype varchar2(256); <br />3 done boolean; <br />4 BEGIN <br />5 devtype := dbms_backup_restore.deviceallocate('', params=&gt;''); <br />6 dbms_backup_restore.restoresetdatafile; <br />7 dbms_backup_restore.restorecontrolfileto('E:\Oracle\oradata\penny\control01.ctl'); <br />8 dbms_backup_restore.restoreDataFileto(1,'E:\Oracle\oradata\penny\system01.dbf'); <br />9 dbms_backup_restore.restoreDataFileto(2,'E:\Oracle\oradata\penny\UNDOTBS01.DBF'); <br />10 dbms_backup_restore.restoreDataFileto(3,'E:\ORACLE\ORADATA\PENNY\USERS01.DBF'); <br />11 dbms_backup_restore.restorebackuppiece('D:\orabak\BACKUP_1_4_04F4IAJT.PENNY',done=&gt;done); <br />12 END; <br />13 / <br />PL/SQL 过程已成功完成。 <br />SQL&gt; alter database mount; <br /><font color="red">[Q]Rman的format格式中的%s类似的东西代表什么意义</font><br />[A]可以参考如下<br />%c 备份片的拷贝数 <br />%d 数据库名称 <br />%D 位于该月中的第几天 (DD) <br />%M 位于该年中的第几月 (MM) <br />%F 一个基于DBID唯一的名称,这个格式的形式为c-IIIIIIIIII-YYYYMMDD-QQ,其中IIIIIIIIII为该数据库的DBID，YYYYMMDD为日期，QQ是一个1-256的序列 <br />%n 数据库名称，向右填补到最大八个字符 <br />%u 一个八个字符的名称代表备份集与创建时间 <br />%p 该备份集中的备份片号，从1开始到创建的文件数<br />%U 一个唯一的文件名，代表%u_%p_%c <br />%s 备份集的号 <br />%t 备份集时间戳 <br />%T 年月日格式(YYYYMMDD)<br /><font color="red">[Q]执行exec dbms_logmnr_d.build('Logminer.ora','file directory')，提示下标超界，怎么办</font><br />[A]完整错误信息如下,<br />SQL&gt; exec dbms_logmnr_d.build('Logminer.ora','file directory') <br />BEGIN dbms_logmnr_d.build('Logminer.ora','file directory'); END; <br />* <br />ERROR 位于第 1 行: <br />ORA-06532: 下标超出限制 <br />ORA-06512: 在"SYS.DBMS_LOGMNR_D", line 793 <br />ORA-06512: 在line 1 <br />解决办法为：<br />1.编辑位于"$ORACLE_HOME/rdbms/admin"目录下的文件"dbmslmd.sql" <br />改变行: <br />TYPE col_desc_array IS VARRAY(513) OF col_description; <br />为<br />TYPE col_desc_array IS VARRAY(700) OF col_description; <br />并保存文件<br />2. 运行改变后的脚本<br />SQLPLUS&gt; Connect internal <br />SQLPLUS&gt; @$ORACLE_HOME/rdbms/admin/dbmslmd.sql <br />3.重新编译该包<br />SQLPLUS&gt; alter package DBMS_LOGMNR_D compile body;<br /><font color="red">[Q]执行execute dbms_logmnr.start_logmnr(DictFileName=&gt;'DictFileName')提示ORA-01843:无效的月份，这个是什么原因</font><br />[A]我们分析start_logmnr包<br />PROCEDURE start_logmnr( <br />startScn IN NUMBER default 0 , <br />endScn IN NUMBER default 0, <br />startTime IN DATE default TO_DATE('01-jan-1988','DD-MON-YYYY'), <br />endTime IN DATE default TO_DATE('01-jan-2988','DD-MON-YYYY'), <br />DictFileName IN VARCHAR2 default '', <br />Options IN BINARY_INTEGER default 0 ); <br />可以知道，如果TO_DATE('01-jan-1988','DD-MON-YYYY')失败，将导致以上错误<br />所以解决办法可以为<br />1、Alter session set NLS_LANGUAGE=American<br />2、用类似如下的方法执行<br />execute dbms_logmnr.start_logmnr (DictFileName=&gt; 'f:\temp2\TESTDICT.ora', starttime =&gt; TO_DATE( <br />'01-01-1988','DD-MM-YYYY'), endTime=&gt;TO_DATE('01-01-2988','DD-MM-YYYY'));</span>
		<br />
		<!---->
		<!---->
		<!---->
		<br />
<img src ="http://www.cppblog.com/ivenher/aggbug/13152.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 17:24 <a href="http://www.cppblog.com/ivenher/articles/13152.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE之常用FAQ V1.0 (1)  第一部分、SQL&amp;PL/SQL</title><link>http://www.cppblog.com/ivenher/articles/13149.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 09:22:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13149.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13149.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13149.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13149.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13149.html</trackback:ping><description><![CDATA[
		<span class="tpc_content" twffan="done">
				<b>第一部分、SQL&amp;PL/SQL<br /></b>
				<br />
				<font color="red">[Q]怎么样查询特殊字符，如通配符%与_</font>
				<br />[A]select * from table where name like 'A\_%' escape '\'<br /><font color="red">[Q]如何插入单引号到数据库表中</font><br />[A]可以用ASCII码处理，其它特殊字符如&amp;也一样，如 <br />insert into t values('i'||chr(39)||'m'); -- chr(39)代表字符'<br />或者用两个单引号表示一个<br />or insert into t values('I''m'); -- 两个''可以表示一个'<br /><font color="red">[Q]怎样设置事务一致性</font><br />[A]set transaction [isolation level] read committed; 默认语句级一致性<br />set transaction [isolation level] serializable;<br />read only; 事务级一致性<br /><font color="red">[Q]怎么样利用游标更新数据</font><br />[A]cursor c1 is <br />select * from tablename <br />where name is null for update [of column]<br />……<br />update tablename set column = ……<br />where current of c1;<br /><font color="red">[Q]怎样自定义异常</font><br />[A] pragma_exception_init(exception_name,error_number);<br />如果立即抛出异常<br />raise_application_error(error_number,error_msg,true|false);<br />其中number从-20000到-20999，错误信息最大2048B<br />异常变量<br />SQLCODE 错误代码<br />SQLERRM 错误信息<br /><font color="red">[Q]十进制与十六进制的转换</font><br />[A]8i以上版本：<br />to_char(100,'XX')<br />to_number('4D','XX')<br />8i以下的进制之间的转换参考如下脚本<br />create or replace function to_base( p_dec in number, p_base in number ) <br />return varchar2 <br />is <br />l_str varchar2(255) default NULL; <br />l_num number default p_dec; <br />l_hex varchar2(16) default '0123456789ABCDEF'; <br />begin <br />if ( p_dec is null or p_base is null ) then <br />return null; <br />end if; <br />if ( trunc(p_dec) p_dec OR p_dec 20;<br /><font color="red">[Q]怎么样抽取重复记录</font><br />[A]select * from table t1 where where t1.rowed !=<br />(select max(rowed) from table t2 <br />where t1.id=t2.id and t1.name=t2.name)<br />或者<br />select count(*), t.col_a,t.col_b from table t<br />group by col_a,col_b<br />having count(*)&gt;1<br />如果想删除重复记录，可以把第一个语句的select替换为delete<br /><font color="red">[Q]怎么样设置自治事务</font><br />[A]8i以上版本，不影响主事务<br />pragma autonomous_transaction;<br />……<br />commit|rollback;<br /><font color="red">[Q]怎么样在过程中暂停指定时间</font><br />[A]DBMS_LOCK包的sleep过程<br />如：dbms_lock.sleep(5);表示暂停5秒。<br /><font color="red">[Q]怎么样快速计算事务的时间与日志量</font><br />[A]可以采用类似如下的脚本<br />DECLARE <br />start_time NUMBER;<br />end_time NUMBER;<br />start_redo_size NUMBER;<br />end_redo_size NUMBER;<br />BEGIN<br />start_time := dbms_utility.get_time;<br />SELECT VALUE INTO start_redo_size FROM v$mystat m,v$statname s <br />WHERE m.STATISTIC#=s.STATISTIC#<br />AND s.NAME='redo size';<br />--transaction start<br />INSERT INTO t1 <br />SELECT * FROM All_Objects; <br />--other dml statement<br />COMMIT;<br />end_time := dbms_utility.get_time;<br />SELECT VALUE INTO end_redo_size FROM v$mystat m,v$statname s <br />WHERE m.STATISTIC#=s.STATISTIC#<br />AND s.NAME='redo size';<br />dbms_output.put_line('Escape Time:'||to_char(end_time-start_time)||' centiseconds');<br />dbms_output.put_line('Redo Size:'||to_char(end_redo_size-start_redo_size)||' bytes');<br />END;<br /><font color="red">[Q]怎样创建临时表</font><br />[A]8i以上版本<br />create global temporary tablename(column list)<br />on commit preserve rows; --提交保留数据 会话临时表<br />on commit delete rows; --提交删除数据 事务临时表<br />临时表是相对于会话的，别的会话看不到该会话的数据。<br /><font color="red">[Q]怎么样在PL/SQL中执行DDL语句</font><br />[A]1、8i以下版本dbms_sql包<br />2、8i以上版本还可以用<br />execute immediate sql;<br />dbms_utility.exec_ddl_statement('sql');<br /><font color="red">[Q]怎么样获取IP地址</font><br />[A]服务器(817以上)：utl_inaddr.get_host_address<br />客户端：sys_context('userenv','ip_address')<br /><font color="red">[Q]怎么样加密存储过程</font><br />[A]用wrap命令，如（假定你的存储过程保存为a.sql）<br />wrap iname=a.sql<br />PL/SQL Wrapper: Release 8.1.7.0.0 - Production on Tue Nov 27 22:26:48 2001<br />Copyright (c) Oracle Corporation 1993, 2000. All Rights Reserved.<br />Processing a.sql to a.plb<br />提示a.sql转换为a.plb，这就是加密了的脚本，执行a.plb即可生成加密了的存储过程<br /><font color="red">[Q]怎么样在ORACLE中定时运行存储过程</font><br />[A]可以利用dbms_job包来定时运行作业，如执行存储过程，一个简单的例子，提交一个作业：<br />VARIABLE jobno number;<br />BEGIN<br />DBMS_JOB.SUBMIT(:jobno, 'ur_procedure;',SYSDATE,'SYSDATE + 1');<br />commit;<br />END;<br />之后，就可以用以下语句查询已经提交的作业<br />select * from user_jobs;<br /><font color="red">[Q]怎么样从数据库中获得毫秒</font><br />[A]9i以上版本，有一个timestamp类型获得毫秒，如<br />SQL&gt;select to_char(systimestamp,'yyyy-mm-dd hh24:mi:ssxff') time1, <br />to_char(current_timestamp) time2 from dual;<br />TIME1 TIME2<br />----------------------------- ----------------------------------------------------------------<br />2003-10-24 10:48:45.656000 24-OCT-03 10.48.45.656000 AM +08:00<br />可以看到，毫秒在to_char中对应的是FF。<br />8i以上版本可以创建一个如下的java函数<br />SQL&gt;create or replace and compile <br />java source<br />named "MyTimestamp"<br />as<br />import java.lang.String;<br />import java.sql.Timestamp;<br />public class MyTimestamp<br />{<br />public static String getTimestamp()<br />{<br />return(new Timestamp(System.currentTimeMillis())).toString();<br />}<br />};<br />SQL&gt;java created.<br />注：注意java的语法，注意大小写<br />SQL&gt;create or replace function my_timestamp return varchar2<br />as language java<br />name 'MyTimestamp.getTimestamp() return java.lang.String';<br />/<br />SQL&gt;function created.<br />SQL&gt;select my_timestamp,to_char(sysdate,'yyyy-mm-dd hh24:mi:ss') ORACLE_TIME from dual;<br />MY_TIMESTAMP ORACLE_TIME<br />------------------------ -------------------<br />2003-03-17 19:15:59.688 2003-03-17 19:15:59 <br />如果只想获得1/100秒(hsecs)，还可以利用dbms_utility.get_time<br /><font color="red">[Q]如果存在就更新，不存在就插入可以用一个语句实现吗</font><br />[A]9i已经支持了，是Merge，但是只支持select子查询，<br />如果是单条数据记录，可以写作select …… from dual的子查询。<br />语法为：<br />MERGE INTO table<br />USING data_source<br />ON (condition)<br />WHEN MATCHED THEN update_clause<br />WHEN NOT MATCHED THEN insert_clause;<br />如<br />MERGE INTO course c<br />USING (SELECT course_name, period,<br />course_hours<br />FROM course_updates) cu<br />ON (c.course_name = cu.course_name<br />AND c.period = cu.period)<br />WHEN MATCHED THEN<br />UPDATE<br />SET c.course_hours = cu.course_hours<br />WHEN NOT MATCHED THEN<br />INSERT (c.course_name, c.period,<br />c.course_hours)<br />VALUES (cu.course_name, cu.period,<br />cu.course_hours);<br /><font color="red">[Q]怎么实现左联，右联与外联</font><br />[A]在9i以前可以这么写:<br />左联：<br />select a.id,a.name,b.address from a,b <br />where a.id=b.id(+)<br />右联:<br />select a.id,a.name,b.address from a,b <br />where a.id(+)=b.id<br />外联<br />SELECT a.id,a.name,b.address<br />FROM a,b<br />WHERE a.id = b.id(+)<br />UNION<br />SELECT b.id,'' name,b.address<br />FROM b<br />WHERE NOT EXISTS (<br />SELECT * FROM a<br />WHERE a.id = b.id);<br />在9i以上，已经开始支持SQL99标准，所以，以上语句可以写成：<br />默认内部联结：<br />select a.id,a.name,b.address,c.subject<br />from (a inner join b on a.id=b.id) <br />inner join c on b.name = c.name<br />where other_clause<br />左联<br />select a.id,a.name,b.address<br />from a left outer join b on a.id=b.id <br />where other_clause<br />右联<br />select a.id,a.name,b.address<br />from a right outer join b on a.id=b.id <br />where other_clause<br />外联<br />select a.id,a.name,b.address<br />from a full outer join b on a.id=b.id <br />where other_clause<br />or<br />select a.id,a.name,b.address<br />from a full outer join b using (id)<br />where other_clause<br /><font color="red">[Q]怎么实现一条记录根据条件多表插入</font><br />[A]9i以上可以通过Insert all语句完成，仅仅是一个语句，如：<br />INSERT ALL<br />WHEN (id=1) THEN<br />INTO table_1 (id, name)<br />values(id,name)<br />WHEN (id=2) THEN<br />INTO table_2 (id, name)<br />values(id,name)<br />ELSE<br />INTO table_other (id, name)<br />values(id, name)<br />SELECT id,name<br />FROM a;<br />如果没有条件的话，则完成每个表的插入，如<br />INSERT ALL<br />INTO table_1 (id, name)<br />values(id,name)<br />INTO table_2 (id, name)<br />values(id,name)<br />INTO table_other (id, name)<br />values(id, name)<br />SELECT id,name<br />FROM a;<br /><font color="red">[Q]如何实现行列转换</font><br />[A]1、固定列数的行列转换<br />如<br />student subject grade<br />---------------------------<br />student1 语文 80<br />student1 数学 70<br />student1 英语 60<br />student2 语文 90<br />student2 数学 80<br />student2 英语 100<br />……<br />转换为 <br />语文 数学 英语<br />student1 80 70 60<br />student2 90 80 100<br />……<br />语句如下：<br />select student,sum(decode(subject,'语文', grade,null)) "语文",<br />sum(decode(subject,'数学', grade,null)) "数学",<br />sum(decode(subject,'英语', grade,null)) "英语"<br />from table<br />group by student<br />2、不定列行列转换<br />如<br />c1 c2<br />--------------<br />1 我<br />1 是<br />1 谁<br />2 知<br />2 道<br />3 不<br />……<br />转换为<br />1 我是谁<br />2 知道<br />3 不<br />这一类型的转换必须借助于PL/SQL来完成，这里给一个例子<br />CREATE OR REPLACE FUNCTION get_c2(tmp_c1 NUMBER) <br />RETURN VARCHAR2 <br />IS <br />Col_c2 VARCHAR2(4000); <br />BEGIN<br />FOR cur IN (SELECT c2 FROM t WHERE c1=tmp_c1) LOOP <br />Col_c2 := Col_c2||cur.c2; <br />END LOOP; <br />Col_c2 := rtrim(Col_c2,1);<br />RETURN Col_c2; <br />END;<br />/<br />SQL&gt; select distinct c1 ,get_c2(c1) cc2 from table;即可<br /><font color="red">[Q]怎么样实现分组取前N条记录</font><br />[A]8i以上版本，利用分析函数<br />如获取每个部门薪水前三名的员工或每个班成绩前三名的学生。<br />Select * from <br />(select depno,ename,sal,row_number() over (partition by depno<br />order by sal desc) rn <br />from emp)<br />where rn host lsntctl start <br />或者unix/linux平台下<br />SQL&gt;!<br />windows平台下<br />SQL&gt;$<br />总结：HOST 可以直接执行OS命令。 <br />备注：cd命令无法正确执行。<br /><font color="red">[Q]怎么设置存储过程的调用者权限</font><br />[A]普通存储过程都是所有者权限，如果想设置调用者权限，请参考如下语句<br />create or replace<br />procedure ……()<br />AUTHID CURRENT_USER<br />As<br />begin<br />……<br />end;<br /><font color="red">[Q]怎么快速获得用户下每个表或表分区的记录数</font><br />[A]可以分析该用户，然后查询user_tables字典，或者采用如下脚本即可<br />SET SERVEROUTPUT ON SIZE 20000<br />DECLARE<br />miCount INTEGER;<br />BEGIN<br />FOR c_tab IN (SELECT table_name FROM user_tables) LOOP<br />EXECUTE IMMEDIATE 'select count(*) from "' || c_tab.table_name || '"' into miCount;<br />dbms_output.put_line(rpad(c_tab.table_name,30,'.') || lpad(miCount,10,'.'));<br />--if it is partition table<br />SELECT COUNT(*) INTO miCount FROM User_Part_Tables WHERE table_name = c_tab.table_name;<br />IF miCount &gt;0 THEN<br />FOR c_part IN (SELECT partition_name FROM user_tab_partitions WHERE table_name = c_tab.table_name) LOOP<br />EXECUTE IMMEDIATE 'select count(*) from ' || c_tab.table_name || ' partition (' || c_part.partition_name || ')' <br />INTO miCount;<br />dbms_output.put_line(' '||rpad(c_part.partition_name,30,'.') || lpad(miCount, 10,'.'));<br />END LOOP;<br />END IF;<br />END LOOP;<br />END;<br /><font color="red">[A]怎么在Oracle中发邮件</font><br />[Q]可以利用utl_smtp包发邮件，以下是一个发送简单邮件的例子程序<br />/****************************************************************************<br />parameter: Rcpter in varchar2 接收者邮箱<br />Mail_Content in Varchar2 邮件内容<br />desc: ·发送邮件到指定邮箱<br />·只能指定一个邮箱，如果需要发送到多个邮箱，需要另外的辅助程序<br />****************************************************************************/<br />CREATE OR REPLACE PROCEDURE sp_send_mail( rcpter IN VARCHAR2,<br />mail_content IN VARCHAR2)<br />IS <br />conn utl_smtp.connection;<br />--write title<br />PROCEDURE send_header(NAME IN VARCHAR2, HEADER IN VARCHAR2) AS<br />BEGIN<br />utl_smtp.write_data(conn, NAME||': '|| HEADER||utl_tcp.CRLF);<br />END;<br />BEGIN<br />--opne connect<br />conn := utl_smtp.open_connection('smtp.com');<br />utl_smtp.helo(conn, 'oracle');<br />utl_smtp.mail(conn, 'oracle info');<br />utl_smtp.rcpt(conn, Rcpter);<br />utl_smtp.open_data(conn);<br />--write title<br />send_header('From', 'Oracle Database');<br />send_header('To', '"Recipient" ');<br />send_header('Subject', 'DB Info');<br />--write mail content<br />utl_smtp.write_data(conn, utl_tcp.crlf || mail_content);<br />--close connect <br />utl_smtp.close_data(conn);<br />utl_smtp.quit(conn);<br />EXCEPTION<br />WHEN utl_smtp.transient_error OR utl_smtp.permanent_error THEN<br />BEGIN<br />utl_smtp.quit(conn);<br />EXCEPTION<br />WHEN OTHERS THEN<br />NULL;<br />END;<br />WHEN OTHERS THEN<br />NULL;<br />END sp_send_mail;<br /><font color="red">[A]怎么样在Oracle中写操作系统文件，如写日志</font><br />[Q]可以利用utl_file包，但是，在此之前，要注意设置好Utl_file_dir初始化参数<br />/**************************************************************************<br />parameter:textContext in varchar2 日志内容<br />desc: ·写日志,把内容记到服务器指定目录下<br />·必须配置Utl_file_dir初始化参数，并保证日志路径与Utl_file_dir路径一致或者是其中一个<br />****************************************************************************/ <br />CREATE OR REPLACE PROCEDURE sp_Write_log(text_context VARCHAR2)<br />IS<br />file_handle utl_file.file_type;<br />Write_content VARCHAR2(1024);<br />Write_file_name VARCHAR2(50);<br />BEGIN<br />--open file<br />write_file_name := 'db_alert.log';<br />file_handle := utl_file.fopen('/u01/logs',write_file_name,'a');<br />write_content := to_char(SYSDATE,'yyyy-mm-dd hh24:mi:ss')||'||'||text_context;<br />--write file<br />IF utl_file.is_open(file_handle) THEN<br />utl_file.put_line(file_handle,write_content);<br />END IF;<br />--close file<br />utl_file.fclose(file_handle);<br />EXCEPTION<br />WHEN OTHERS THEN<br />BEGIN<br />IF utl_file.is_open(file_handle) THEN<br />utl_file.fclose(file_handle);<br />END IF;<br />EXCEPTION<br />WHEN OTHERS THEN<br />NULL;<br />END;<br />END sp_Write_log;</span>
		<br />
		<!---->
		<!---->
		<!---->
		<br />
<img src ="http://www.cppblog.com/ivenher/aggbug/13149.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 17:22 <a href="http://www.cppblog.com/ivenher/articles/13149.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>ORACLE中使用动态游标的例子 </title><link>http://www.cppblog.com/ivenher/articles/13146.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 29 Sep 2006 07:54:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13146.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13146.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13146.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13146.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13146.html</trackback:ping><description><![CDATA[create or replace function get_ope_popedom(sta_id varchar2) return varchar2<br />  /*<br />   * NAME：<br />   *   get_ope_popedom<br />   *<br />   * PARAMETER：<br />   *   sta_id   - 车站编号，多个站时以逗号分隔<br />   *<br />   * RETURN:<br />   *   --对应车站编号的车站名称，多个站时以逗号分隔<br />   *<br />   * AUTHOR:<br />   *   舵手<br />   *<br />   * DESCRIPTION:<br />   *   --根据传入的车站编号返回相应的车站名称<br />   *<br />   */<br />as<br />Result varchar2(1000);<br />name_temp varchar2(40);<br />type cursor_t is ref cursor;<br />emp_cur cursor_t ;<br />begin<br />  OPEN emp_cur FOR 'SELECT sta_name FROM station_code where sta_code =:1'<br />  using sta_id;<br />  LOOP<br />      FETCH emp_cur INTO name_temp; <br />      If (emp_cur%NOTFOUND) Then<br />         EXIT;<br />      End if; <br />      Result := Result || name_temp || ',';<br />  end loop;<br />  close emp_cur;<br />  Result := substr(Result,1,(length(Result)-1));<br />  return(Result);<br />end get_ope_popedom;<br /><img src ="http://www.cppblog.com/ivenher/aggbug/13146.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-29 15:54 <a href="http://www.cppblog.com/ivenher/articles/13146.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>[Oracle]中如何掌握与使用游标（1）</title><link>http://www.cppblog.com/ivenher/articles/13101.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Thu, 28 Sep 2006 06:17:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/13101.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/13101.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/13101.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/13101.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/13101.html</trackback:ping><description><![CDATA[
		<a name="_Toc112150288">
				<font size="2">
						<span lang="EN-US">1<span></span></span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: Arial; mso-hansi-font-family: Arial">游标的属性</span>
				</font>
		</a>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="3">
				<font size="2">
						<span lang="EN-US">　　oracle </span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">游标有</span>
						<span lang="EN-US">4</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">个属性：</span>
						<span lang="EN-US">%ISOPEN</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">，</span>
						<span lang="EN-US">%FOUND</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">，</span>
						<span lang="EN-US">%NOTFOUND</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">，</span>
						<span lang="EN-US">%ROWCOUNT</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">。</span>
				</font>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="4">
				<font size="2">
						<span lang="EN-US">　　%ISOPEN</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">判断游标是否被打开，如果打开</span>
						<span lang="EN-US">%ISOPEN</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">等于</span>
						<span lang="EN-US">true,</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">否则等于</span>
						<span lang="EN-US">false</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">；</span>
				</font>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="5">
				<font size="2">
						<span lang="EN-US">　　%FOUND %NOTFOUND</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">判断游标所在的行是否有效，如果有效，则</span>
						<span lang="EN-US">%FOUNDD</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">等于</span>
						<span lang="EN-US">true</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">，否则等于</span>
						<span lang="EN-US">false</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">；</span>
				</font>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="6">
				<font size="2">
						<span lang="EN-US">　　%ROWCOUNT</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">返回当前位置为止游标读取的记录行数。</span>
				</font>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: center" align="center">
		</p>
		<div id="7">
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　隐式游标和显式游标</font>
				</span>
		</div>
		<p>
		</p>
		<div id="8">
				<div align="center">
						<table style="mso-cellspacing: 0cm" cellspacing="0" cellpadding="0" width="500" border="1">
								<tbody>
										<tr>
												<td>
														<div>
														</div>
														<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: center" align="center">
														</p>
														<div id="9">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">隐式游标</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="10">
																<div id="14">
																		<div id="18">
																				<div id="22">
																						<div id="26">
																						</div>
																				</div>
																		</div>
																</div>
														</div>
												</td>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: center" align="center">
														</p>
														<div id="11">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">显式游标</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="12">
																<div id="16">
																		<div id="20">
																				<div id="24">
																				</div>
																		</div>
																</div>
														</div>
												</td>
										</tr>
										<tr>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="13">
																<font size="2">
																		<span lang="EN-US">PL/SQL</span>
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">维护，当执行查询时自动打开和关闭</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="10">
																<div id="14">
																		<div id="18">
																				<div id="22">
																						<div id="26">
																						</div>
																				</div>
																		</div>
																</div>
														</div>
												</td>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="15">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">在程序中显式定义、打开、关闭，游标有一个名字。</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="12">
																<div id="16">
																		<div id="20">
																				<div id="24">
																				</div>
																		</div>
																</div>
														</div>
												</td>
										</tr>
										<tr>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="17">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">游标属性前缀是</span>
																		<span lang="EN-US">SQL </span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="10">
																<div id="14">
																		<div id="18">
																				<div id="22">
																						<div id="26">
																						</div>
																				</div>
																		</div>
																</div>
														</div>
												</td>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="19">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">游标属性的前缀是游标名</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="12">
																<div id="16">
																		<div id="20">
																				<div id="24">
																				</div>
																		</div>
																</div>
														</div>
												</td>
										</tr>
										<tr>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="21">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">属性</span>
																		<span lang="EN-US">%ISOPEN</span>
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">总是为</span>
																		<span lang="EN-US">FALSE </span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="10">
																<div id="14">
																		<div id="18">
																				<div id="22">
																						<div id="26">
																						</div>
																				</div>
																		</div>
																</div>
														</div>
												</td>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="23">
																<font size="2">
																		<span lang="EN-US">%ISOPEN</span>
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">根据游标的状态确定值</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="12">
																<div id="16">
																		<div id="20">
																				<div id="24">
																				</div>
																		</div>
																</div>
														</div>
												</td>
										</tr>
										<tr>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="25">
																<font size="2">
																		<span lang="EN-US">SELECT</span>
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">语句带有</span>
																		<span lang="EN-US">INTO</span>
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">子串，只有一行数据被处理</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="10">
																<div id="14">
																		<div id="18">
																				<div id="22">
																						<div id="26">
																						</div>
																				</div>
																		</div>
																</div>
														</div>
												</td>
												<td>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<div>
														</div>
														<p class="MsoNormal">
														</p>
														<div id="27">
																<font size="2">
																		<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">可以处理多行数据，在程序中设置循环，取出每一行数据。</span>
																		<span lang="EN-US" style="FONT-SIZE: 12pt; FONT-FAMILY: " unicode="" arial="">
																				<o>
																				</o>
																		</span>
																</font>
														</div>
														<p>
														</p>
														<div id="28">
														</div>
												</td>
										</tr>
								</tbody>
						</table>
				</div>
		</div>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt">
		</p>
		<div id="29">
				<span lang="EN-US">
						<font size="2">
								<o>
								</o>
						</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21.1pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="30">
				<strong>
						<font size="2">
								<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">　　记录变量</span>
								<span lang="EN-US">
										<o>
										</o>
								</span>
						</font>
				</strong>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt">
		</p>
		<div id="31">
				<font size="2">
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">　　定义一个记录变量使用</span>
						<span lang="EN-US">TYPE</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">命令和</span>
						<span lang="EN-US">%ROWTYPE</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">，</span>
				</font>
		</div>
		<p>
		</p>
		<div id="32">
				<div id="48">
						<span lang="EN-US">
						</span>
				</div>
		</div>
		<div style="SCROLLBAR-HIGHLIGHT-COLOR: buttonhighlight; OVERFLOW: auto; WIDTH: 500px">
				<pre style="BORDER-RIGHT: black 1px solid; PADDING-RIGHT: 4px; BORDER-TOP: black 1px solid; PADDING-LEFT: 4px; PADDING-BOTTOM: 4px; BORDER-LEFT: black 1px solid; PADDING-TOP: 4px; BORDER-BOTTOM: black 1px solid; BACKGROUND-COLOR: #ededed">
						<div id="33">
								<div>
										<!--Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->
										<font size="2">
												<span style="COLOR: #0000ff">DECLARE</span>
										</font>
										<span style="COLOR: #000000">
												<font size="2">R_emp EMP</font>
										</span>
										<span style="COLOR: #808080">
												<font size="2">%</font>
										</span>
										<font size="2">
												<span style="COLOR: #000000">ROWTYPE;</span>
												<span style="COLOR: #0000ff">CURSOR</span>
												<span style="COLOR: #000000"> c_emp </span>
												<span style="COLOR: #0000ff">IS</span>
												<span style="COLOR: #000000">
												</span>
												<span style="COLOR: #0000ff">SELECT</span>
												<span style="COLOR: #000000">
												</span>
												<span style="COLOR: #808080">*</span>
												<span style="COLOR: #000000">
												</span>
												<span style="COLOR: #0000ff">FROM</span>
												<span style="COLOR: #000000"> emp;</span>
										</font>
								</div>
						</div>
				</pre>
		</div>
		<div id="34">
				<div id="38">
				</div>
		</div>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="35">
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　或：</font>
				</span>
		</div>
		<p>
		</p>
		<div id="36">
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
				</span>
		</div>
		<div style="SCROLLBAR-HIGHLIGHT-COLOR: buttonhighlight; OVERFLOW: auto; WIDTH: 500px">
				<pre style="BORDER-RIGHT: black 1px solid; PADDING-RIGHT: 4px; BORDER-TOP: black 1px solid; PADDING-LEFT: 4px; PADDING-BOTTOM: 4px; BORDER-LEFT: black 1px solid; PADDING-TOP: 4px; BORDER-BOTTOM: black 1px solid; BACKGROUND-COLOR: #ededed">
						<div id="37">
								<div>
										<!--Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->
										<span style="COLOR: #0000ff">DECLARE</span>
										<span style="COLOR: #000000">
										</span>
										<span style="COLOR: #0000ff">CURSOR</span>
										<span style="COLOR: #000000"> c_emp </span>
										<span style="COLOR: #0000ff">IS</span>
										<span style="COLOR: #000000">
										</span>
										<span style="COLOR: #0000ff">SELECT</span>
										<span style="COLOR: #000000"> ename,salary </span>
										<span style="COLOR: #0000ff">FROM</span>
										<span style="COLOR: #000000"> emp;R_emp c_emp</span>
										<span style="COLOR: #808080">%</span>
										<span style="COLOR: #000000">ROWTYPE;</span>
								</div>
						</div>
				</pre>
		</div>
		<div id="34">
				<div id="38">
				</div>
		</div>
		<p class="MsoNormal" style="TEXT-INDENT: 21.1pt">
		</p>
		<div id="39">
				<strong>
						<font size="2">
								<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">　　带参数的游标</span>
								<span lang="EN-US">
										<o>
										</o>
								</span>
						</font>
				</strong>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt">
		</p>
		<div id="40">
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　与存储过程和函数相似，可以将参数传递给游标并在查询中使用。这对于处理在某种条件下打开游标的情况非常有用。它的语法如下：</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt">
		</p>
		<div id="41">
				<span lang="EN-US">
						<font size="2">　　CURSOR cursor_name[(parameter[,parameter],...)] IS select_statement;</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="MARGIN-BOTTOM: 12pt; TEXT-INDENT: 21pt">
		</p>
		<div id="42">
				<span lang="EN-US">
				</span>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　定义参数的语法如下：</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="MARGIN-BOTTOM: 12pt; TEXT-INDENT: 21pt">
		</p>
		<div id="43">
				<span lang="EN-US">
						<font size="2">　　Parameter_name [IN] data_type[{:=|DEFAULT} value]</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　与存储过程不同的是，游标只能接受传递的值，而不能返回值。参数只定义数据类型，没有大小。</font>
				</span>
				<span lang="EN-US">
				</span>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　</font>
				</span>
		</div>
		<div>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　</font>
				</span>
		</div>
		<div>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　另外可以给参数设定一个缺省值，当没有参数值传递给游标时，就使用缺省值。游标中定义的参数只是一个占位符，在别处引用该参数不一定可靠。</font>
				</span>
				<span lang="EN-US">
						<br />
				</span>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　</font>
				</span>
		</div>
		<div>
				<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
						<font size="2">　　在打开游标时给参数赋值，语法如下：</font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="45">
				<span lang="EN-US">
						<font size="2">　　OPEN cursor_name[value[,value]....];<strong><span><o></o></span></strong></font>
				</span>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21.1pt; TEXT-ALIGN: left" align="left">
		</p>
		<div id="46">
				<strong>
						<font size="2">
								<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">　　游标</span>
								<span lang="EN-US">FOR</span>
								<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">循环</span>
								<span lang="EN-US">
										<o>
										</o>
								</span>
						</font>
				</strong>
		</div>
		<p>
		</p>
		<p class="MsoNormal" style="TEXT-INDENT: 21pt">
		</p>
		<div id="47">
				<font size="2">
						<span lang="EN-US">　　FOR</span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">循环的游标按照正常的声明方式声明，它的优点在于不需要显式的打开、关闭、取数据，测试数据的存在、定义存放数据的变量等等。游标</span>
						<span lang="EN-US">FOR </span>
						<span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">循环的语法如下：</span>
				</font>
		</div>
		<p>
		</p>
		<div id="32">
				<div id="48">
						<span lang="EN-US">
						</span>
				</div>
		</div>
		<div style="SCROLLBAR-HIGHLIGHT-COLOR: buttonhighlight; OVERFLOW: auto; WIDTH: 500px">
				<pre style="BORDER-RIGHT: black 1px solid; PADDING-RIGHT: 4px; BORDER-TOP: black 1px solid; PADDING-LEFT: 4px; PADDING-BOTTOM: 4px; BORDER-LEFT: black 1px solid; PADDING-TOP: 4px; BORDER-BOTTOM: black 1px solid; BACKGROUND-COLOR: #ededed">
						<div id="49">
								<div>
										<!--Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->
										<font size="2">
												<span style="COLOR: #0000ff">FOR</span>
												<span style="COLOR: #000000"> record_name </span>
												<span style="COLOR: #808080">IN</span>
										</font>
										<span style="COLOR: #000000">
												<font size="2">(corsor_name</font>
										</span>
										<font size="2">
												<span style="COLOR: #ff0000">[</span>
												<span style="COLOR: #ff0000">(parameter[,parameter</span>
												<span style="COLOR: #ff0000">]</span>
										</font>
										<font size="2">
												<span style="COLOR: #000000">...)]</span>
												<span style="COLOR: #808080">|</span>
										</font>
										<font size="2">
												<span style="COLOR: #000000"> (query_difinition)LOOPstatements</span>
												<span style="COLOR: #0000ff">END</span>
												<span style="COLOR: #000000"> LOOP;</span>
										</font>
								</div>
						</div>
				</pre>
		</div>
		<div id="ParagraphCount" style="DISPLAY: none"> </div>
<img src ="http://www.cppblog.com/ivenher/aggbug/13101.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-28 14:17 <a href="http://www.cppblog.com/ivenher/articles/13101.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Oracle PL/SQL语言基础 三</title><link>http://www.cppblog.com/ivenher/articles/12987.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Tue, 26 Sep 2006 08:52:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/12987.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/12987.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/12987.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/12987.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/12987.html</trackback:ping><description><![CDATA[
		<strong>
				<font color="#ac0000">控制结构<br /><br /></font>
		</strong>　　控制结构控制PL/SQL程序流程的代码行,PL/SQL支持条件控制和循环控制结构。<br /><br />　　语法和用途<br /><br />　　　IF..THEN<br /><br />　　语法：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>IF condition THEN<br />　Statements 1;<br />　Statements 2;<br />　....<br />END IF <br /></td></tr></tbody></table><br />　　IF语句判断条件condition是否为TRUE，如果是，则执行THEN后面的语句，如果condition为false或NULL则跳过THEN到END IF之间的语句，执行END IF后面的语句。<br /><br />　　<b>IF..THEN...ELSE</b><br /><br />　　语法:<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>IF condition THEN<br />　Statements 1;<br />　Statements 2;<br />　....<br />ELSE<br />　Statements 1;<br />　Statements 2;<br />　....<br />END IF </td></tr></tbody></table><br />　　如果条件condition为TRUE,则执行THEN到ELSE之间的语句，否则执行ELSE到END IF之间的语句。<br /><br />　　IF 可以嵌套，可以在IF 或IF ..ELSE语句中使用IF或IF..ELSE语句。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>if (a&gt;b) and (a&gt;c) then<br />　　g:=a;<br />else<br />　　g:=b;<br />　　if c&gt;g then<br />　　　g:=c;<br />　　end if<br />end if</td></tr></tbody></table><br />　　<b>IF..THEN..ELSIF</b><br /><br />　　语法：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>IF condition1 THEN<br />　statement1;<br />ELSIF condition2 THEN<br />　statement2;<br />ELSIF condition3 THEN<br />　statement3;<br />ELSE<br />　statement4;<br />END IF;<br />　statement5;<br /></td></tr></tbody></table><br />　　如果条件condition1为TRUE则执行statement1,然后执行statement5,否则判断condition2是否为TRUE,若为TRUE则执行statement2,然后执行statement5,对于condition3也是相同的，如果condition1，condition2，condition3都不成立，那么将执行statement4,然后执行statement5。<br /><br />　　<font color="#ac000"><b>循环控制</b></font><br /><br />　　循环控制的基本形式是LOOP语句，LOOP和END LOOP之间的语句将无限次的执行。LOOP语句的语法如下：<br /><br />　　LOOP <br />　　　statements;<br />　　END LOOP<br /><br />　　LOOP和END LOOP之间的语句无限次的执行显然是不行的，那么在使用LOOP语句时必须使用EXIT语句，强制循环结束，例如：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>X:=100;<br />LOOP<br />　X:=X+10;<br />　IF X&gt;1000 THEN<br />　　EXIT;<br />　END IF<br />END LOOP;<br />Y:=X;</td></tr></tbody></table><br />　　此时Y的值是1010.<br /><br />　　EXIT WHEN语句将结束循环，如果条件为TRUE，则结束循环。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>X:=100;<br />LOOP<br />X:=X+10;<br />EXIT WHEN X&gt;1000;<br />X:=X+10;<br />END LOOP;<br />Y:=X;<br /></td></tr></tbody></table><br />　　<b>WHILE..LOOP</b><br /><br />　　WHILE..LOOP有一个条件与循环相联系，如果条件为TRUE,则执行循环体内的语句，如果结果为FALSE,则结束循环。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>X:=100;<br />WHILE X&lt;=1000 LOOP<br />　X:=X+10;<br />END LOOP;<br />Y=X; </td></tr></tbody></table><br />　　<b>FOR...LOOP</b><br /><br />　　语法：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>FOR counter IN [REVERSE] start_range....end_range LOOP<br />statements;<br />END LOOP;</td></tr></tbody></table><br />　　LOOP和WHILE循环的循环次数都是不确定的，FOR循环的循环次数是固定的，counter是一个隐式声明的变量，他的初始值是start_range,第二个值是start_range+1,直到end_range,如果start_range等于end _range,那么循环将执行一次。如果使用了REVERSE关键字，那么范围将是一个降序。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>X:=100;<br />FOR v_counter in 1..10 loop<br />x:=x+10;<br /><br />end loop<br />y:=x;</td></tr></tbody></table><br />　　如果要退出for循环可以使用EXIT语句。<br /><br />　　<b>标签</b><br /><br />　　用户可以使用标签使程序获得更好的可读性。程序块或循环都可以被标记。标签的形式是&lt;<label>&gt;。<br /><br />　　标记程序块<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>&lt;<label_name>&gt;<br />[DECLARE]<br />... ... ...<br />BEGIN<br />........<br />[EXCEPTION]<br />.......<br />END label_name</label_name></td></tr></tbody></table><br />　　标记循环<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>&lt;<outer_name>&gt;<br />LOOP<br />.........<br />&lt;<inner_loop>&gt;<br />loop<br />..........<br />&lt;<innermost_loop>&gt;<br />loop<br />....<br /><br />EXIT outer_loop WHEN v_condition=0;<br />end loop innermost_loop;<br />..........<br />END LOOP inner_loop;<br />END LOOP outer_loop; </innermost_loop></inner_loop></outer_name></td></tr></tbody></table><br />　　<b>GOTO语句</b><br /><br />　　语法：<br /><br />　　GOTO LABEL;<br /><br />　　执行GOTO语句时，控制会立即转到由标签标记的语句。PL/SQL中对GOTO语句有一些限制，对于块、循环、IF语句而言，从外层跳转到内层是非法的。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>X ：=100;<br />FOR V_COUNTER IN 1..10 LOOP<br />　IF V_COUNTER =4 THEN<br />　　GOTO end_of_loop<br />　END IF<br />　X:=X+10;<br />　&lt;<end_of_loop>&gt;<br />　NULL<br />END LOOP<br /><br />Y:=X; </end_of_loop></td></tr></tbody></table><br />　　注意：NULL是一个合法的可执行语句。<br /><br />　　<b>嵌套</b><br /><br />　　程序块的内部可以有另一个程序块这种情况称为嵌套。嵌套要注意的是变量，定义在最外部程序块中的变量可以在所有子块中使用，如果在子块中定义了与外部程序块变量相同的变量名，在执行子块时将使用子块中定义的变量。子块中定义的变量不能被父块引用。同样GOTO语句不能由父块跳转道子块中，反之则是合法的。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>《OUTER BLOCK》<br />DECLARE<br />　A_NUMBER INTEGER；<br />　B_NUMBER INTEGER；<br />BEGIN<br />　--A_NUMBER and B_NUMBER are available here<br />　&lt;<sub_block>&gt;<br />　DECLARE<br />　C_NUMBER INTEGER<br />　B_NUMBER NUMBER(20)<br />BEGIN<br />　C_NUMBER:=A_NUMBER;<br />　C_NUMBER=OUTER_BLOCK.B_NUMBER;<br />END SUB_BLOCK;<br />END OUT_BLOCK;<br /></sub_block></td></tr></tbody></table><br />　　<font color="#ac000"><b>小结</b></font><br /><br />　 我们在这篇文章中介绍了PL/SQL的基础语法以及如何使用PL/SQL语言设计和运行PL/SQL程序块，并将PL/SQL程序整合到Oracle服务器中,虽然PL/SQL程序作为功能块嵌入Oracle数据库中，但PL/SQL与ORACLE数据库的紧密结合使得越来越多的Oracle数据库管理员和开发人员开始使用PL/SQL。</label><img src ="http://www.cppblog.com/ivenher/aggbug/12987.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-26 16:52 <a href="http://www.cppblog.com/ivenher/articles/12987.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Oracle PL/SQL语言基础 二</title><link>http://www.cppblog.com/ivenher/articles/12986.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Tue, 26 Sep 2006 08:51:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/12986.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/12986.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/12986.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/12986.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/12986.html</trackback:ping><description><![CDATA[
		<strong>
				<font color="#ac0000">变量和常量<br /><br /></font>
		</strong>　　变量存放在内存中以获得值，能被PL/SQL块引用。你可以把变量想象成一个可储藏东西的容器，容器内的东西是可以改变的。<br /><br />　　<b>声明变量</b><br /><br />　　变量一般都在PL/SQL块的声明部分声明，PL/SQL是一种强壮的类型语言，这就是说在引用变量前必须首先声明，要在执行或异常处理部分使用变量，那么变量必须首先在声明部分进行声明。<br /><br />　　声明变量的语法如下：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>Variable_name [CONSTANT] databyte [NOT NULL][:=|DEFAULT expression]</td></tr></tbody></table><br />　　注意:可以在声明变量的同时给变量强制性的加上NOT NULL约束条件，此时变量在初始化时必须赋值。<br /><br />　　<b>给变量赋值</b><br /><br />　　给变量赋值有两种方式：<br /><br />　　. 直接给变量赋值<br /><br />　　　X:=200;<br />　　　Y=Y+(X*20);<br /><br />　　. 通过SQL SELECT INTO 或FETCH INTO给变量赋值<br /><br />SELECT SUM(SALARY),SUM(SALARY*0.1)<br />INTO TOTAL_SALARY,TATAL_COMMISSION<br />FROM EMPLOYEE<br />WHERE DEPT=10;<br /><br />　　<b>常量</b><br /><br />　　常量与变量相似，但常量的值在程序内部不能改变，常量的值在定义时赋予，，他的声明方式与变量相似，但必须包括关键字CONSTANT。常量和变量都可被定义为SQL和用户定义的数据类型。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>ZERO_VALUE CONSTANT NUMBER:=0;</td></tr></tbody></table><br />　　这个语句定了一个名叫ZERO_VALUE、数据类型是NUMBER、值为0的常量。<br /><br />　　标量(scalar)数据类型<br /><br />　　标量(scalar)数据类型没有内部组件，他们大致可分为以下四类：<br /><br />　　　. number<br />　　　. character<br />　　　. date/time<br />　　　. boolean<br /><br />　　表1显示了数字数据类型；表2显示了字符数据类型；表3显示了日期和布尔数据类型。<br /><br />　　表1 Scalar Types:Numeric<br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>Datatype</td><td>Range</td><td>Subtypes</td><td>description</td></tr><tr><td valign="top" height="85">BINARY_INTEGER</td><td valign="top" height="85">-214748-2147483647</td><td valign="top" height="85">NATURAL<br />NATURAL<br />NPOSITIVE<br />POSITIVEN<br />SIGNTYPE <br /></td><td valign="top" height="85">用于存储单字节整数。<br />要求存储长度低于NUMBER值。<br />用于限制范围的子类型(SUBTYPE):<br />　NATURAL:用于非负数<br />　POSITIVE:只用于正数<br />　NATURALN:只用于非负数和非NULL值<br />　POSITIVEN:只用于正数，不能用于NULL值<br />　SIGNTYPE:只有值:-1、0或1.</td></tr><tr><td valign="top">NUMBER</td><td valign="top">1.0E-130-9.99E125</td><td>DEC<br />DECIMAL<br />DOUBLE <br />PRECISION<br />FLOAT <br />INTEGERIC<br />INT<br />NUMERIC<br />REAL<br />SMALLINT</td><td valign="top">存储数字值，包括整数和浮点数。可以选择精度和刻度方式，语法：<br />number[（<precision>[,<scale>]）]。<br />缺省的精度是38,scale是0.</scale></precision></td></tr><tr><td>PLS_INTEGER</td><td>-2147483647-2147483647</td><td> </td><td>与BINARY_INTEGER基本相同，但采用机器运算时，PLS_INTEGER提供更好的性能 。</td></tr></tbody></table><br />　　表2 字符数据类型 <br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>datatype</td><td>rang</td><td>subtype</td><td>description</td></tr><tr><td>CHAR</td><td>最大长度32767字节 </td><td>CHARACTER</td><td>存储定长字符串，如果长度没有确定，缺省是1</td></tr><tr><td>LONG</td><td>最大长度2147483647字节</td><td> </td><td>存储可变长度字符串</td></tr><tr><td>RAW </td><td>最大长度32767字节</td><td> </td><td>用于存储二进制数据和字节字符串，当在两个数据库之间进行传递时，RAW数据不在字符集之间进行转换。</td></tr><tr><td>LONGRAW</td><td>最大长度2147483647</td><td> </td><td>与LONG数据类型相似，同样他也不能在字符集之间进行转换。</td></tr><tr><td>ROWID</td><td>18个字节</td><td> </td><td>与数据库ROWID伪列类型相同，能够存储一个行标示符，可以将行标示符看作数据库中每一行的唯一键值。</td></tr><tr><td>VARCHAR2</td><td>最大长度32767字节</td><td>STRINGVARCHAR</td><td>与VARCHAR数据类型相似，存储可变长度的字符串。声明方法与VARCHAR相同 </td></tr></tbody></table><br />　　表3 DATE和BOOLEAN<br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>datatype</td><td>range </td><td>description</td></tr><tr><td>BOOLEAN</td><td>TRUE/FALSE</td><td>存储逻辑值TRUE或FALSE,无参数</td></tr><tr><td>DATE</td><td>01/01/4712 BC </td><td>存储固定长的日期和时间值，日期值中包含时间</td></tr></tbody></table><br />　　LOB数据类型<br /><br />　　LOB(大对象,Large object) 数据类型用于存储类似图像，声音这样的大型数据对象，LOB数据对象可以是二进制数据也可以是字符数据，其最大长度不超过4G。LOB数据类型支持任意访问方式，LONG只支持顺序访问方式。LOB存储在一个单独的位置上，同时一个"LOB定位符"(LOB locator)存储在原始的表中，该定位符是一个指向实际数据的指针。在PL/SQL中操作LOB数据对象使用ORACLE提供的包DBMS_LOB.LOB数据类型可分为以下四类：<br /><br />　　. BFILE<br />　　. BLOB<br />　　. CLOB<br />　　. NCLOB<br /><br />　　操作符<br /><br />　　与其他程序设计语言相同，PL/SQL有一系列操作符。操作符分为下面几类：<br /><br />　　. 算术操作符<br /><br />　　. 关系操作符<br /><br />　　. 比较操作符<br /><br />　　. 逻辑操作符<br /><br />　　算术操作符如表4所示<br /><br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>operator</td><td>operation</td></tr><tr><td>+ </td><td>加</td></tr><tr><td>- </td><td>减</td></tr><tr><td>/ </td><td>除</td></tr><tr><td>* </td><td>乘</td></tr><tr><td>**</td><td>乘方</td></tr></tbody></table><br />　　关系操作符主要用于条件判断语句或用于where子串中，关系操作符检查条件和结果是否为true或false,表5是PL/SQL中的关系操作符<br /><br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>operator</td><td>operation</td></tr><tr><td>&lt; </td><td>小于操作符</td></tr><tr><td>&lt;= </td><td>小于或等于操作符</td></tr><tr><td>&gt; </td><td>大于操作符</td></tr><tr><td>&gt;=</td><td>大于或等于操作符</td></tr><tr><td>= </td><td>等于操作符 </td></tr><tr><td>!= </td><td>不等于操作符</td></tr><tr><td>&lt;&gt; </td><td>不等于操作符</td></tr><tr><td>:= </td><td>赋值操作符</td></tr></tbody></table><br />　　表6 显示的是比较操作符<br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>operator </td><td>operation</td></tr><tr><td>IS NULL</td><td>如果操作数为NULL返回TRUE</td></tr><tr><td>LIKE</td><td>比较字符串值</td></tr><tr><td>BETWEEN</td><td>验证值是否在范围之内</td></tr><tr><td>IN</td><td>验证操作数在设定的一系列值中</td></tr></tbody></table><br />　　表7.8显示的是逻辑操作符<br /><table cellspacing="0" width="100%" border="1"><tbody><tr><td>operator</td><td>operation</td></tr><tr><td>AND </td><td>两个条件都必须满足</td></tr><tr><td>OR</td><td>只要满足两个条件中的一个</td></tr><tr><td>NOT</td><td>取反</td></tr></tbody></table><br />　　<b>执行部分</b><br /><br />　　执行部分包含了所有的语句和表达式,执行部分以关键字BEGIN开始，以关键字EXCEPTION结束，如果EXCEPTION不存在，那么将以关键字END结束。分号分隔每一条语句，使用赋值操作符:=或SELECT INTO或FETCH INTO给每个变量赋值，执行部分的错误将在异常处理部分解决，在执行部分中可以使用另一个PL/SQL程序块，这种程序块被称为嵌套块<br /><br />　　所有的SQL数据操作语句都可以用于执行部分，PL/SQL块不能再屏幕上显示SELECT语句的输出。SELECT语句必须包括一个INTO子串或者是游标的一部分，执行部分使用的变量和常量必须首先在声明部分声明，执行部分必须至少包括一条可执行语句，NULL是一条合法的可执行语句，事物控制语句COMMIT和ROLLBACK可以在执行部分使用，数据定义语言(Data Definition language)不能在执行部分中使用，DDL语句与EXECUTE IMMEDIATE一起使用或者是DBMS_SQL调用。<br /><br />　　<strong>执行一个PL/SQL块<br /></strong><br />　　SQL*PLUS中匿名的PL/SQL块的执行是在PL/SQL块后输入/来执行，如下面的例子所示：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>declare <br />　v_comm_percent constant number:=10;<br />begin<br />　update emp<br />　set comm=sal*v_comm_percent<br />　where deptno=10;<br />　end<br />SQL&gt; /<br />PL/SQL procedure successfully completed.<br /><br />SQL&gt;</td></tr></tbody></table><br />　　命名的程序与匿名程序的执行不同，执行命名的程序块必须使用execute关键字：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>create or replace procedure update_commission<br />　(v_dept in number,v_pervent in number default 10) is <br />begin<br />　update emp<br />　set comm=sal*v_percent<br />　where deptno=v_dept;<br />end<br /><br />SQL&gt;/<br /><br />Procedure created<br /><br />SQL&gt;execute update_commission(10,15);<br /><br />PL/SQL procedure successfully completed.<br /><br />SQL&gt; </td></tr></tbody></table><br /><br />　　如果在另一个命名程序块或匿名程序块中执行这个程序，那么就不需要EXECUTE关进字。<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>declare<br />　v_dept number;<br />begin<br />　select a.deptno<br />　into v_dept<br />　from emp a<br />　where job='PRESIDENT'<br />　update_commission(v_dept);<br />end<br />SQL&gt;/<br />　PL/SQL procedure successfully completed<br />SQL&gt;</td></tr></tbody></table><img src ="http://www.cppblog.com/ivenher/aggbug/12986.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-26 16:51 <a href="http://www.cppblog.com/ivenher/articles/12986.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>PL/SQL 语言基础</title><link>http://www.cppblog.com/ivenher/articles/12985.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Tue, 26 Sep 2006 08:49:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/12985.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/12985.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/12985.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/12985.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/12985.html</trackback:ping><description><![CDATA[PL/SQL是ORACLE对标准数据库语言的扩展，ORACLE公司已经将PL/SQL整合到ORACLE 服务器和其他工具中了，近几年中更多的开发人员和DBA开始使用PL/SQL，本文将讲述PL/SQL基础语法，结构和组件、以及如何设计并执行一个PL/SQL程序。<br /><br />　　<b><font color="#ac000">PL/SQL的优点</font></b><br /><br />　　从版本6开始PL/SQL就被可靠的整合到ORACLE中了，一旦掌握PL/SQL的优点以及其独有的数据管理的便利性，那么你很难想象ORACLE缺了PL/SQL的情形。PL/SQL 不是一个独立的产品，他是一个整合到ORACLE服务器和ORACLE工具中的技术，可以把PL/SQL看作ORACLE服务器内的一个引擎，sql语句执行者处理单个的sql语句，PL/SQL引擎处理PL/SQL程序块。当PL/SQL程序块在PL/SQL引擎处理时，ORACLE服务器中的SQL语句执行器处理pl/sql程序块中的SQL语句。<br /><br />　　<b>PL/SQL的优点如下：</b><br /><br />　　. PL/SQL是一种高性能的基于事务处理的语言，能运行在任何ORACLE环境中，支持所有数据处理命令。通过使用PL/SQL程序单元处理SQL的数据定义和数据控制元素。<br /><br />　　. PL/SQL支持所有SQL数据类型和所有SQL函数，同时支持所有ORACLE对象类型<br /><br />　　. PL/SQL块可以被命名和存储在ORACLE服务器中，同时也能被其他的PL/SQL程序或SQL命令调用，任何客户/服务器工具都能访问PL/SQL程序，具有很好的可重用性。<br /><br />　　. 可以使用ORACLE数据工具管理存储在服务器中的PL/SQL程序的安全性。可以授权或撤销数据库其他用户访问PL/SQL程序的能力。<br /><br />　　. PL/SQL代码可以使用任何ASCII文本编辑器编写，所以对任何ORACLE能够运行的操作系统都是非常便利的<br /><br />　　. 对于SQL，ORACLE必须在同一时间处理每一条SQL语句，在网络环境下这就意味作每一个独立的调用都必须被oracle服务器处理，这就占用大量的服务器时间，同时导致网络拥挤。而PL/SQL是以整个语句块发给服务器，这就降低了网络拥挤。<br /><br />　　<font color="#ac000"><b>PL/SQL块结构</b></font><br /><br />　　PL/SQL是一种块结构的语言，组成PL/SQL程序的单元是逻辑块，一个PL/SQL 程序包含了一个或多个逻辑块，每个块都可以划分为三个部分。与其他语言相同，变量在使用之前必须声明，PL/SQL提供了独立的专门用于处理异常的部分，下面描述了PL/SQL块的不同部分：<br /><br />　　<b>声明部分(Declaration section)</b><br /><br />　　声明部分包含了变量和常量的数据类型和初始值。这个部分是由关键字DECLARE开始，如果不需要声明变量或常量，那么可以忽略这一部分；需要说明的是游标的声明也在这一部分。<br /><br />　　<b>执行部分(Executable section)</b><br /><br />　　执行部分是PL/SQL块中的指令部分，由关键字BEGIN开始，所有的可执行语句都放在这一部分，其他的PL/SQL块也可以放在这一部分。<br /><br />　　<b>异常处理部分(Exception section)</b><br /><br />　　这一部分是可选的，在这一部分中处理异常或错误，对异常处理的详细讨论我们在后面进行。<br /><br />　　<b>PL/SQL块语法</b><br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>[DECLARE]<br />---declaration statements<br />BEGIN<br />---executable statements<br />[EXCEPTION]<br />---exception statements<br />END<br /></td></tr></tbody></table><br />　　PL/SQL块中的每一条语句都必须以分号结束，SQL语句可以使多行的，但分号表示该语句的结束。一行中可以有多条SQL语句，他们之间以分号分隔。每一个PL/SQL块由BEGIN或DECLARE开始，以END结束。注释由--标示。<br /><br />　　<font color="#ac000"><b>PL/SQL块的命名和匿名</b></font><br /><br />　　PL/SQL程序块可以是一个命名的程序块也可以是一个匿名程序块。匿名程序块可以用在服务器端也可以用在客户端。<br /><br />　　命名程序块可以出现在其他PL/SQL程序块的声明部分，这方面比较明显的是子程序，子程序可以在执行部分引用，也可以在异常处理部分引用。<br /><br />　　PL/SQL程序块可背独立编译并存储在数据库中，任何与数据库相连接的应用程序都可以访问这些存储的PL/SQL程序块。ORACLE提供了四种类型的可存储的程序：<br /><br />　　　. 函数<br /><br />　　　. 过程<br /><br />　　　. 包<br /><br />　　　. 触发器<br /><br />　　<b>函数</b><br /><br />　　函数是命名了的、存储在数据库中的PL/SQL程序块。函数接受零个或多个输入参数，有一个返回值，返回值的数据类型在创建函数时定义。定义函数的语法如下：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>FUNCTION name [{parameter[,parameter,...])] RETURN datatypes IS<br />[local declarations]<br />BEGIN<br />execute statements<br />[EXCEPTION<br />exception handlers]<br />END [name]</td></tr></tbody></table><br />　　<b>过程</b><br /><br />　　存储过程是一个PL/SQL程序块，接受零个或多个参数作为输入(INPUT)或输出(OUTPUT)、或既作输入又作输出(INOUT)，与函数不同，存储过程没有返回值，存储过程不能由SQL语句直接使用，只能通过EXECUT命令或PL/SQL程序块内部调用，定义存储过程的语法如下：<br /><br /><table width="100%" bgcolor="#ffffff"><tbody><tr><td>PROCEDURE name [(parameter[,parameter,...])] IS<br />[local declarations]<br />BEGIN<br />execute statements<br />[EXCEPTION<br />exception handlers ]<br />END [name]</td></tr></tbody></table><br />　　<b>包(package)</b><br /><br />　　包其实就是被组合在一起的相关对象的集合，当包中任何函数或存储过程被调用，包就被加载入内存中，包中的任何函数或存储过程的子程序访问速度将大大加快。<br />包由两个部分组成：规范和包主体(body),规范描述变量、常量、游标、和子程序，包体完全定义子程序和游标。<br /><br />　　<b>触发器(trigger)</b><br /><br />　　触发器与一个表或数据库事件联系在一起的，当一个触发器事件发生时，定义在表上的触发器被触发。<br /><img src ="http://www.cppblog.com/ivenher/aggbug/12985.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-26 16:49 <a href="http://www.cppblog.com/ivenher/articles/12985.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>[oracle]触发器及序列结合实现自增字段</title><link>http://www.cppblog.com/ivenher/articles/12949.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Mon, 25 Sep 2006 09:45:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/12949.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/12949.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/12949.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/12949.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/12949.html</trackback:ping><description><![CDATA[
		<h4 class="TextColor1" id="subjcns!ffb54a583bc34d22!442" style="MARGIN-BOTTOM: 0px">[oracle]触发器及序列结合实现自增字段</h4>
		<div id="msgcns!ffb54a583bc34d22!442">
				<div>
						<ul>
								<font size="3">
										<strong>让oracle实现自增字段</strong>
								</font>
								<br />
								<p>
										<font color="#000080" size="2">
												<span>
														<font face="Courier New" color="#000000">先建序列,然后建立一个触发器实现!<br />cata0是表名,cata0_id是需要自增的字段!<br />CREATE SEQUENCE SEQ_cata0<br /> INCREMENT BY  1<br /> START WITH  1<br /> MAXVALUE  9999999<br /><br />CREATE TRIGGER TRG_cata0 BEFORE<br />INSERT  ON cata0<br />FOR EACH ROW begin<br />   SELECT SEQ_cata0.NEXTVAL<br />     INTO :NEW.cata0_ID<br />     FROM DUAL;<br />End TRG_cata0;</font>
												</span>
										</font>
								</p>
						</ul>
				</div>
		</div>
<img src ="http://www.cppblog.com/ivenher/aggbug/12949.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-25 17:45 <a href="http://www.cppblog.com/ivenher/articles/12949.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>oracle查询前几行</title><link>http://www.cppblog.com/ivenher/articles/12833.html</link><dc:creator>爱饭盒</dc:creator><author>爱饭盒</author><pubDate>Fri, 22 Sep 2006 08:30:00 GMT</pubDate><guid>http://www.cppblog.com/ivenher/articles/12833.html</guid><wfw:comment>http://www.cppblog.com/ivenher/comments/12833.html</wfw:comment><comments>http://www.cppblog.com/ivenher/articles/12833.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/ivenher/comments/commentRss/12833.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/ivenher/services/trackbacks/12833.html</trackback:ping><description><![CDATA[
		<p>查询前100行记录<br />select * from  mytab where rownum&lt;100</p>
<img src ="http://www.cppblog.com/ivenher/aggbug/12833.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/ivenher/" target="_blank">爱饭盒</a> 2006-09-22 16:30 <a href="http://www.cppblog.com/ivenher/articles/12833.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>