﻿<?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>BlogJava-把永恒在一刹那间收藏-文章分类-database</title><link>http://www.blogjava.net/gm_jing/category/16430.html</link><description>生活之点点滴滴</description><language>zh-cn</language><lastBuildDate>Sat, 14 Aug 2010 05:08:24 GMT</lastBuildDate><pubDate>Sat, 14 Aug 2010 05:08:24 GMT</pubDate><ttl>60</ttl><item><title>Some performance considerations for temporary tablespaces</title><link>http://www.blogjava.net/gm_jing/articles/328782.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:53:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328782.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328782.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328782.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328782.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328782.html</trackback:ping><description><![CDATA[<h1 class="title">TEMPORARY Tablespaces and TEMPFILES</h1>
<!-- start main content -->
<div class="node">
<span class="submitted">Submitted by admin on Thu, 2003-06-19
02:28</span>
<span class="taxonomy">
<ul class="links inline">
    <li class="taxonomy_term_9 first last"><a href="http://www.orafaq.com/articles/server" rel="tag" title="Oracle
    RDBMS Server Articles">RDBMS Server</a></li>
</ul>
</span>
<div class="picture">
</div>
<div class="content">
<p><span style="font-weight: bold;">What are
Temporary Tablespaces:</span></p>
<p>Temporary tablespaces are used to manage space for database sort
operations and for storing global temporary tables. For example, if you
join two large tables, and Oracle cannot do the sort in memory (see
SORT_AREA_SIZE initialisation parameter), space will be allocated in a
temporary tablespace for doing the sort operation. Other SQL operations
that might require disk sorting are: CREATE INDEX, ANALYZE, Select
DISTINCT, ORDER BY, GROUP BY,  UNION, INTERSECT, MINUS, Sort-Merge
joins, etc.</p>
<p>The DBA should assign a temporary tablespace to each user in the
database to prevent them from allocating sort space in the SYSTEM
tablespace. This can be done with one of the following commands:</p>
<pre class="bb-code-block">SQL&gt; CREATE USER scott DEFAULT TABLESPACE data TEMPORARY TABLESPACE temp;<br />
SQL&gt; ALTER USER scott TEMPORARY TABLESPACE temp;</pre>
<p>Note that a temporary tablespace cannot contain permanent objects and
therefore doesn't need to be backed up. </p>
<p><span style="font-weight: bold;">What are TEMPFILES?</span></p>
<p>Unlike normal data files, TEMPFILEs are not fully initialised
(sparse). When you create a TEMPFILE, Oracle only writes to the header
and last block of the file. This is why it is much quicker to create a
TEMPFILE than to create a normal database file.  </p>
<p>TEMPFILEs are not recorded in the database's control file. This
implies that one can just recreate them whenever you restore the
database, or after deleting them by accident. This opens interesting
possibilities like having different TEMPFILE configurations between
permanent and standby databases, or configure TEMPFILEs to be local
instead of shared in a RAC environment.</p>
<p>One cannot remove datafiles from a tablespace until you drop the
entire tablespace. However, one can remove a TEMPFILE from a database.
Look at his example:</p>
<p><code class="bb-code">SQL&gt; ALTER DATABASE TEMPFILE
'/oradata/temp02.dbf' DROP INCLUDING DATAFILES;</code></p>
<p>If you remove all tempfiles from a temporary tablespace, you may
encounter error: ORA-25153: Temporary Tablespace is Empty. Use the
following statement to add a TEMPFILE to a temporary tablespace:</p>
<p><code class="bb-code">SQL&gt; ALTER TABLESPACE temp ADD TEMPFILE
'/oradata/temp03.dbf' SIZE 100M;</code></p>
<p>Except for adding a tempfile, as illustrated in the above example,
you cannot use the ALTER TABLESPACE statement for a locally managed
temporary tablespace (operations like rename, set to read only, recover,
etc. will fail). </p>
<p><span style="font-weight: bold;">How does one create Temporary
Tablespaces?</span></p>
<p>Oracle provides various ways of creating TEMPORARY tablespaces
(mainly to provide backward compatibility). One should use the most
recent method available: </p>
<p>- Prior to Oracle 7.3 - CREATE TABLESPACE temp DATAFILE ...;<br />
- Oracle 7.3 &amp; 8.0 - CREATE TABLESPACE temp DATAFILE ... TEMPORARY;<br />
- Oracle 8i and above - CREATE TEMPORARY TABLESPACE temp TEMPFILE ...;</p>
<p>Oracle 8i and 9i example:</p>
<pre class="bb-code-block">SQL&gt; CREATE TEMPORARY TABLESPACE temp <br />
TEMPFILE '/oradata/mytemp_01.tmp' SIZE 20M<br />
EXTENT MANAGEMENT LOCAL UNIFORM SIZE 16M;</pre>
<p>For best performance, the UNIFORM SIZE must be a multiple of the
SORT_AREA_SIZE parameter.</p>
<p>Oracle 9i example using OMF (Oracle Managed Files):</p>
<p><code class="bb-code">SQL&gt; CREATE TEMPORARY TABLESPACE temp;</code></p>
<p><span style="font-weight: bold;">Default Temporary Tablespaces:</span></p>
<p>In Oracle 9i and above, one can define a Default Temporary Tablespace
at database creation time, or by issuing an "ALTER DATABASE" statement:</p>
<p><code class="bb-code">ALTER DATABASE DEFAULT TEMPORARY TABLESPACE
temp;</code></p>
<p>The default Default Temporary Tablespace is SYSTEM. Each database can
be assigned one and only one Default Temporary Tablespace. Using this
feature, a Temporary Tablespace is automatically assigned to users. The
following restrictions apply to default temporary tablespaces:</p>
<p>- The Default Temporary Tablespace must be of type TEMPORARY<br />
- The DEFAULT TEMPORARY TABLESPACE cannot be taken off-line<br />
- The DEFAULT TEMPORARY TABLESPACE  cannot be dropped until you create
another one.</p>
<p>To see the default temporary tablespace for a database, execute the
following query:</p>
<p><code class="bb-code">SQL&gt; SELECT * FROM DATABASE_PROPERTIES where
PROPERTY_NAME='DEFAULT_TEMP_TABLESPACE';</code></p>
<p>All new users that are not explicitly assigned a TEMPORARY
TABLESPACE, will get the Default Temporary Tablespace as its TEMPORARY
TABLESPACE. Also, when you assign a TEMPORARY tablespace to a user,
Oracle will not change this value next time you change the Default
Temporary Tablespace for the database.</p>
<p><span style="font-weight: bold;">Other Considerations:</span></p>
<p>Some performance considerations for temporary tablespaces:</p>
<p>- Always use temporary tablespaces instead of permanent content
tablespaces for sorting (no logging and uses one large sort segment to
reduce recursive SQL and ST space management enqueue contention).<br />
- Ensure that you create your temporary tablespaces as locally managed
instead of dictionary managed (Use sort space bitmap instead of sys.fet$
and sys.uet$ for allocating space).<br />
- Always use TEMPFILEs instead of DATAFILEs (reduce backup and recovery
time + other advantages as described above)<br />
- Stripe your temporary tablespaces over multiple disks to alleviate
possible disk contention and to speed-up sorting operations (user
processes can read/write to it directly).</p>
<p><span style="font-weight: bold;">Monitoring Temporary Tablespaces and
Sorting:</span></p>
<p>Unlike datafiles, tempfiles are not listed in V$DATAFILE and
DBA_DATA_FILES. Use V$TEMPFILE and DBA_TEMP_FILES instead.</p>
<p>One can monitor temporary segments from V$SORT_SEGMENT and
V$SORT_USAGE</p>
<p>DBA_FREE_SPACE does not record free space for temporary tablespaces.
Use V$TEMP_SPACE_HEADER instead:</p>
<pre class="bb-code-block">SQL&gt; select TABLESPACE_NAME, BYTES_USED, BYTES_FREE from V$TEMP_SPACE_HEADER;<br />
<br />
TABLESPACE_NAME                BYTES_USED BYTES_FREE<br />
------------------------------ ---------- ----------<br />
TEMP                             52428800   52428800</pre>
<br />
</div>
<div class="links">&#187;
<ul class="links inline">
    <li class="blog_usernames_blog first"><a href="http://www.orafaq.com/blog/admin" title="Read admin's latest blog
    entries.">admin's blog</a></li>
    <li class="comment_forbidden last"><span><a href="http://www.orafaq.com/user/login?destination=node%2F2%23comment-form">Login</a>
    to post comments</span></li>
</ul>
</div>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328782.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:53 <a href="http://www.blogjava.net/gm_jing/articles/328782.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>管理表空间(修改表空间)【引用】</title><link>http://www.blogjava.net/gm_jing/articles/328779.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:40:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328779.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328779.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328779.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328779.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328779.html</trackback:ping><description><![CDATA[<br />
<p>四、修改表空间<br />
不论是字典管理表空间还是本地管理表空间，在表空间被创建之后都可以进行修改。可以使用ALTER TABALESPACE来修改表空间。相应的，用户</p>
<p>必须拥有ALTER TABLESPACE或ALTER DATABASE系统权限才能够修改表空间。</p>
<p>(一)扩展表空间<br />
表空间在物理上是由保存在磁盘上的数据文件组成的。创建数据文件时会指定大小，因此表空间是有大小的。为了给用户提供更大的表空间，</p>
<p>以便使其可以继续增加数据，就必须能够扩展表空间，即增加更多存储空间。通常扩展表空间的方法有添加数据文件、改变数据文件的大小、</p>
<p>允许数据文件自动扩展这三种方式。</p>
<p>(1)添加数据文件<br />
因为表空间的大小实际上就是它所包含的各个数据文件的大小和，所以为表空间增加新的数据文件是最常用的扩展表空间的办法。<br />
注意：不能为大文件表空间增加第二个数据文件。<br />
ALTER TABLESPACE mytbs01 ADD DATAFILE 'e:\mytbs01_2.dbf' SIZE 3M;<br />
与普通表空间不同，如果要为临时表空间添加新的临时数据文件，就必须使用ALTER TABLESPACE...ADD TEMPFILE语句。<br />
ALTER TABLESPACE mytmptbs01 ADD TEMPFILE 'e:\mytmptbs01_2.dbf' SIZE 3M;</p>
<p>(2)改变数据文件的大小<br />
通过增加表空间中已有数据文件的大小，也可以增加表空间的存储空间。<br />
ALTER DATABASE DATAFILE 'e:\mytbs01_2.dbf' RESIZE 4M;<br />
与普通表空间不同，如果要改变临时表空间的临时文件的大小，就必须使用ALTER DATABASE TEMPFILE...RESIZE语句。<br />
当数据文件中的可用空间未使用完时，允许减小它的大小，即进行压缩。</p>
<p>(3)允许数据文件自动扩展<br />
如果在创建表空间或为表空间增加数据文件时，没有在数据文件子句中指定AUTOEXTEND选项，则该数据文件的大小是不会自动扩展或增加的。</p>
<p>为了是数据文件可以自动扩展，就必须指定AUTOEXTEND ON选项。在指定了AUTOEXTEND
ON选项后，当表空间被填满时，数据文件就会自动扩展</p>
<p>，从而就间接的增加了表空间的存储空间。<br />
ALTER DATABASE DATAFILE 'e:\mytbs01_2.dbf' AUTOEXTEND ON NEXT 1M MAXSIZE
20M;</p>
<p>(二)修改属性、状态<br />
(1)修改表空间的可用性<br />
新创建的表空间都处于联机(ONLINE)状态。此时该表空间是可以被访问的。但当表空间处于脱机(OFFLINE)状态时，该表空间就不能被SQL语句</p>
<p>访问了。因此，表空间是否联机，表明了表空间是否可用。<br />
修改表空间可用性的语法是:<br />
ALTER TABLESPACE ONLINE|OFFLINE [NORMAL|TEMPORARY|IMMEDIATE|FOR
RECOVER];</p>
<p>使表空间脱机<br />
为了提高数据文件的I/O性能，可能需要移动特定表空间的数据文件。为了确保表空间中数据文件的一致性，在移动数据文件之前，需要将该表</p>
<p>空间修改为脱机状态，以防止其中的数据文件被修改。<br />
SYSTEM,SYSAUX,TEMP,UNDOTBS1表空间是不能被脱机的，因为ORACLE要随时使用这几个表空间。<br />
当表空间修改为脱机状态后，与其相关的数据文件的SCN值和内容都不会发生任何变化。<br />
ALTER TABLESPACE mytbs01 OFFLINE;<br />
当表空间处于脱机状态时，就不能访问该表空间了，否则会有错误的提示。<br />
ALTER TABLESPACE mytbs01 ONLINE;<br />
ALTER TABLESPACE mytbs01 OFFLINE TEMPORARY;<br />
ALTER TABLESPACE mytbs01 ONLINE;<br />
要在ARCHIVELOG模式下执行立即脱机模式。</p>
<p>使表空间联机<br />
完成其他对表空间的维护操作后，应该立即将表空间转变为ONLINE状态，以便该表空间可以被访问。<br />
ALTER TABLESPACE mytbs01 ONLINE;</p>
<p>(2)修改表空间的可读写性<br />
修改表空间的可读写包括使表空间只读和使表空间可读写。</p>
<p>使表空间只读<br />
如果表空间值用于存放静态数据，或者要将表空间移动到其他数据库，就应该先将表空间修改为只读状态。<br />
SYSTEM,SYSAUX,TEMP,UNDOTBS1这几个表空间不能被只读，因为ORACLE要随时向这几个表空间写入数据。<br />
将表空间吸怪为只读状态后，与其相关的数据文件中的SCN值和内容都不会发生任何变化。<br />
ALTER TABLESPACE mytbs01 READ ONLY;<br />
当表空间处于READ ONLY状态时，就不能对该表空间操作了，否则会有错误提示。<br />
当表空间处于只读状态时，仍然允许执行DROP 操作删除该表空间上的对象。<br />
DROP TABLE personal CASCADE CONSTRAINTS;<br />
表空间的可读写状态在脱机之后仍然保留，换句话说就是练级后的其可读写性仍然存在。<br />
如果表空间处于脱机状态，就不能修改它的可读写状态，否则将会有错误提示信息。</p>
<p>使表空间可读写<br />
正常情况下，表空间是可读写的，即可以在该表空间上执行正常的DDL和DML操作。<br />
ALTER TABLESPACE mytbs01 READ WRITE;</p>
<p>(3)修改表空间的备份模式<br />
如果执行非RMAN(RON-RECOVERY MANAGER)联机备份，即在ARCHIVELOG模式下的热备份，则需要修改表空间的备份模式。<br />
首先执行ALTER TABLESPACE tablespace_name BEGIN
BACKUP语句，将表空间tablespace_name设置成备份模式，类似于系统给需要备份的表空</p>
<p>间加锁，防止在备份过程中用户对此表空间进行操作。当表空间处于备份模式时，数据库继续写数据到数据文件(当检查点出现时)，但这些检</p>
<p>查点的出现不被记录到数据文件的头部块中。这就告诉数据库，图过数据库例程被突然中断，就可能需要恢复。如果有必要，一些附加的信息</p>
<p>会被写入重做日志文件，以便有助于恢复。<br />
然后使用一些操作系统的命令程序，将该表空间中的各个数据文件都备份到某些文件夹中或存储设备上。<br />
最后执行ALTER TABLESPACE tablespace_name END
BACKUP语句，将表空间tablespace_name设置成结束备份模式，类似于系统给正在备份的表</p>
<p>空间解锁，以便用户对此空间进行操作。如果忘记了将表空间设置成结束备份模式，则下一次启动数据库时，数据库将会看到控制文件中的检</p>
<p>查点号晚于数据文件头部块中的检查好，并提示一个需要进行介质恢复的信息。</p>
<p>(4)修改表空间的名称<br />
通过使用ALTER TABLESPACE的RENAME选项，DBA就可以修改表空间的名称。在ORACLE
9I之前，移动表空间时，如果在目标数据库中存在同名表</p>
<p>空间，那么该表空间将不能被移动到目标数据库；而在ORACLE 10G中，如果目标数据库存在同名表空间，可以先使用ALTER
TABLESPACE命令修</p>
<p>改源数据库或目标数据库的相应表空间名，然后再移动表空间。<br />
SYSTEM,SYSAUX,TEMP,UNDOTBS1表空间的名称不能被移动。<br />
ALTER TABLESPACE mytbs01 RENAME TO mytbs01_new;<br />
当表空间或其任何数据文件爱你处于OFFLINE状态时，不能修改表空间的名称。</p>
<p>(5)设置、查询默认表空间<br />
在创建数据库用户时，如果没有用DEFAULT TABLESPACE选项指定默认表空间，则使用数据库的默认表空间。如果没有用DEFAULT
TEMPORARY</p>
<p>TABLESPACE选项指定临时表空间，则使用数据库的默认临时表空间。在ORACLE
10G中，初始的默认临时表空间是TEMP，而默认表空间随用户的</p>
<p>不同而不同。</p>
<p>设置数据库默认表空间<br />
可以使用ALTER DATABASE DEFAULT TABLESPACE语句，修改数据库的默认表空间。<br />
ALTER DATABASE DEFAULT TABLESPACE mytbs01;</p>
<p>设置数据库默认临时表空间<br />
可以使用ALTER DATABASE DEFAULT TEMPORARY TABLESPACE语句，修改数据库的默认临时表空间按。<br />
ALTER DATABASE DEFAULT TEMPORARY TABLESPACE mytmptbs01;</p>
<p>查询数据库的默认表空间<br />
可以使用以下语句查询当前数据库的默认表空间。<br />
SELECT username,default_tablespace,temporary_tablespae FROM DBA_UERS;<br />
永久表空间与临时表空间是有区别的，所以如果就爱你个一个永久表空间设置为数据库的临时表空间就会有错误提示。</p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328779.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:40 <a href="http://www.blogjava.net/gm_jing/articles/328779.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>管理表空间(删除表空间)【引用】</title><link>http://www.blogjava.net/gm_jing/articles/328780.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:40:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328780.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328780.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328780.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328780.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328780.html</trackback:ping><description><![CDATA[五、删除表空间<br />
<div id="blog_text" class="cnt">
<p>
如果不再需要一个表空间及其内容(该表空间所包含的段，或所有的数据文件)，就可以将该表空间中从数据库中删除。ORACLE数据库中的任何</p>
<p>表空间，除系统必须的表空间(SYSTEM,SYSAUX,TEMP)外，都可以被删除。<br />
一旦一个表空间已经被删除，该表空间的数据就不能恢复了。因而，一定要确保一个将被删除的表空间所包含的所有数据将来都不再需要了。</p>
<p>另外，在从数据库删除表空间的前后，都需要对数据库做一次完全备份。这样即使错误的删除了一个表空间，如果数据库在删除表空间后遇到</p>
<p>问题，还能够恢复该数据库。<br />
不能删除包含任何活动端的表空间。为了简单，应该是表空间在被删除之间脱机。<br />
要删除一个表空间，使用DROP TABLESPACE tablespace_name语句。用户必须拥有DROP
TABLESPACE系统权限才能删除一个表空间。<br />
要删除一个非空的表空间，就要使用INCLUDING CONTENTS选项，否则会有错误提示。<br />
以上的语句只会从数据字典、控制文件删除表空间信息，而与其相关的数据文件仍然存在于磁盘上。但是，当表空间一旦被删除，无论它所包</p>
<p>括的数据文件是否被删除，这些数据文件爱你都会时区作用。<br />
从ORACLE 9I开始，在删除表空间的同时还可以联机的删除与其相关的数据文件。当然，如果在ORACLE删除表空间的同时，没有只是它删除数据</p>
<p>文件，就必须在以后使用合适的操作系统命令来删除他们。<br />
要删除一个表空间的同时删除与他相关的数据文件，就必须使用INCLUDING CONTENTS AND DATAFILES子句。<br />
ALTER TABLESPACE mytbs06 OFFLINE;<br />
DROP TABLESPACE mytbs06 INCLUDING CONTENTS AND DATAFILES;</p>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328780.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:40 <a href="http://www.blogjava.net/gm_jing/articles/328780.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>管理表空间(创建表空间)【引用】</title><link>http://www.blogjava.net/gm_jing/articles/328778.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:39:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328778.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328778.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328778.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328778.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328778.html</trackback:ping><description><![CDATA[三、创建表空间<br />
<div id="blog_text" class="cnt">
<p>
创建表空间的步骤因操作系统带的不同而不同。然而，在所有的情况中，用户都应该事先通过操作系统的功能创建一个目录结构，以便将新表</p>
<p>空间的数据文件(一个表空间必须要有一个数据文件)分配到相应的目录中。在大多数操作系统中，当通过添加数据文件来创建一个新表空间或</p>
<p>修改一个表空间时，应该指出大小和完全限定的文件名(即包括目录结构和文件的扩展名)。在每一种情况中，都由ORACLE按所指定的信息来自</p>
<p>动创建和格式化数据文件。<br />
与表空间对应的物理结构是数据文件。在创建表空间的过程中要指定它所使用的数据文件的位置和文件名。实际上，在表空间的创建中，</p>
<p>ORACLE会完成以下几个工作：<br />
1.在数据字典和控制文件中记录该新创建的表空间；<br />
2.在操作系统中按指定的位置和文件名创建指定大小的操作系统文件，作为该表空间对应的数据文件；<br />
3.在预警文件中记录创建表空间的信息。</p>
<p>CREATE TABLESPACE 创建(永久)表空间<br />
CREATE BIGFILE TABLESPACE 创建大文件表空间<br />
CREATE TEMPORARY TABLESPACE 创建临时表空间<br />
CREATE UNDO TABLESPACE 创建撤销表空间</p>
<p>用户必须拥有CREATE
TABLESPACE系统权限才能创建表空间。临时表空间和撤销表空间都是特殊表空间，他们与一般表空间不同的是，用户并不</p>
<p>能在其中创建方案对象，因此，需要在CREATE语句中添加TEMPORARY和UNDO关键词。<br />
在ORACLE 8I以前，所有的表空间都创建为字典管理。从ORACLE 8I开始，用户能够创建本地管理的表空间，他们使用位图代替了数据字典表开</p>
<p>跟踪已用的和空闲的空间。因为本地管理的表空间有更好的性能，而且更加容易管理，所以，从ORACLE 9I开始，创建(永久)表空间都是本地管</p>
<p>理的。</p>
<p>创建表空间的语法是：<br />
CREATE [SMALLFILE|BIGFILE] [PERMANENT|TEMPORARY|UNDO] TABLESPACE<br />
DATAFILE|TEMPFILE datafile_clause[,datafile_clause]<br />
[EXTENT MANAGEMENT LOCAL]<br />
[AUTOALLOCATE|UNIFORM SIZE integer [K|M]]<br />
[SEGMENT SPACE MANAGEMENT AUTO|MANUAL]<br />
[BLOCKSIZE integer[K|M]]<br />
[MININUM EXTENT integer [K|M]]<br />
[LOGGING|NOLOGGING]<br />
[ONLINE|OFFLINE [NORMAL|TEMPORARY|IMMEDIATE]];</p>
<p>其中，datafile_clause子句(数据文件子句)的语法是：<br />
'path_filename_suffix' SIZE integer [K|M]<br />
[REUSE]<br />
[AUTOEXTEND OFF|ON]<br />
[NEXT integer [K|M]]<br />
[MAXSIZE UNLIMITED | integer [K|M]]<br />
在datafile_clause子句中指定数据文件时，不能使用相对路径，只能使用绝对路径。并且，如果没有提供文件名的后缀，则无后缀。</p>
<p>(一)创建(永久)表空间<br />
如果不指定PERMANENT,TEMPORARY,UNDO选项，或指定了PERMANENT选项，则创建的是永久表空间，即永久保存其中的数据库对象
的数据。<br />
有三种创建(永久)表空间的方法：<br />
(1)使用AUTOALLOCATE区分配方式<br />
如果DBA能够预测到表空间中存放的度喜爱那个所需要的区大小会有很大不同，则使用AUTOALLOCATE区分配方式是比较好的选择。在这种方式下</p>
<p>，ORACLE将自动按表空间中不同对象的大小分配相应大小的区(有一个表大小与区大小的对应关系，最小的区为64KB)。
AUTOALLOCATE区分配方</p>
<p>式的缺点是在表空间中可能会造成一些磁盘空间的浪费，但是这一点代价相对DBA工作量的减少来说是值得的。<br />
CREATE TABLESPACE mytbs01 DATAFILE 'e:\mytbs01.dbf' SIZE 2M
AUTOALLOCATE;</p>
<p>(2)使用UNIFORM区分配方式<br />
如果DBA能够预测到表空间中存放的大部分对象都要求使用相同大小的区，那么，使用UNIFORM区分配方式是比较好的选择。在这种情况下，</p>
<p>ORACLE将为表空间中所有对象都分配指定的相同
大小的区(默认大小是1MB)。UNIFORM区分配方式的优点是在表空间中不会产生磁盘碎片，节约</p>
<p>磁盘空间。<br />
CREATE TABLESPACE mytbs02 DATAFILE 'e:\mytbs02_1.dbf' SIZE 1M,
'e:\mytbs02_2' SIZE 2M UNIFORM SIZE 128K;</p>
<p>(3)在数据字典子句中指定数据文件的扩展方式<br />
可以在数据文件子句中指定数据文件的扩展方式。<br />
CREATE TABLESPACE mytbs03 DATAFILE 'e:\mytbs03_1.dbf' SIZE 1M AUTOEXTEND
ON NEXT 2M MAXSIZE 11M;<br />
但是此时就不能再指定表空间的区分配方式了，否则会有错误提示。</p>
<p>(4)使用AUTO段管理方式<br />
可以使用SEGMENT SPACE
MANAGEMENT子句来指定表空间的段管理方式，即管理段中已用数据块和空闲数据块的方式。虽然ORACLE极力推荐为本</p>
<p>地管理的永久表空间使用AUTO段管理方式，但在ORACLE 10G中如果不使用SEGMENT SPACE
MANAGEMENT子句指定AUTO,则使用MANUAL段管理方式。<br />
CREATE TABLESPACE mytbs04 DATAFILE 'e:\mytbs04_1.dbf' SIZE 3M REUSE
UNIFORM SEGMENT SPACE MANAGEMENT AUTO;</p>
<p>(5)使用BLOCKSIZE选项和创建非标准块表空间<br />
有时候要求数据库支持多个块大小的表空间(大表的数据存放在大块的表空间上更有效)，即必须创建有不同于初始化参数DB_BLOCK_SIZE指定的</p>
<p>标准的ORACLE块大小的表空间，此时就可以使用这个选项。这个选项只适用于永久表空间。<br />
例如现在DB_BLOCK_SIZE参数的值是8K，则可以创建BLOCKSIZE选项是8K的表空间(如果不用BLOCKSIZE选项指定块的大小，就
采用DB_BLOCK_SIZE</p>
<p>参数指定的大小)。<br />
CREATE TABLESPACE mytbs05 DATAFILE 'e:\mytbs05_1.dbf' SIZE 3M REUSE
BLOCKSIZE 8K SEGMENT SPACE MANAGEMENT AUTO;<br />
但可能不能创建BLOCKSIZE参数值为16K的表空间，否则会有错误提示：<br />
CRAETE TABLESPACE mytbs06 DATAFILE 'e:\mytbs06_1.dbf' SIZE 3M REUSE
BLOCKSIZE 16K SEGMENT SPACE MANAGEMENT AUTO;<br />
如果要为不同的表空间指定不同的块大小，就需要先修改初始化参数文件中的数据高速缓存区参数</p>
<p>(DB_2K_CACHE_SIZE,DB_4K_CACHE_SIZE,DB_8K_CACHE_SIZE,<br />
DB_16K_CACHE_SIZE,DB_32K_CACHE_SIZE)才行</p>
<p>(二)创建大文件表空间<br />
大文件表空间是ORACLE 10G数据库的新特性，而且仅在本地管理的表空间中才支持大文件表空间。这种表空间只能包括一个数据文件，该数据</p>
<p>文件可以包含4G个块。能显著提高ORACLE数据库的存储能力并减少数据文件的个数。<br />
CREATE BIGFILE TABLESPACE mybigtbs01 DATAFILE 'e:\mybigtbs01_1.dbf' SIZE
2M SEGMENT SPACE MANAGEMENT AUTO;<br />
在创建大文件表空间时可以指定区分配方式，但不能将段管理方式指定为MANUAL方式。<br />
CREATE BIGFILE TABLESPACE mybigtbs02 DATAFILE 'e:\mybigtbs02_1.dbf' SIZE
2M UNIFORM SIZE 128K;<br />
但是<br />
CREATE BIGFILE TABLESPACE mybigtbs03 DATAFILE 'e:\mybigtbs03_1.dbf' SIZE
2M SEGMENT SPACE MANAGEMENT MANUAL;就会出现错误提示</p>
<p>。</p>
<p>(三)创建临时表空间<br />
如果指定了TEMPORARY选项，则创建的就是临时表空间，即ORACLE会用这种表空间来创建临时段，以便排序操作时使用。这个临时段是全体用户</p>
<p>共享的，即使排序操作结束了，ORACLE也不会释放这个临时段。这可以提高排序操作较多的应用系统的执行性能，因为ORACLE不必每次遇到一</p>
<p>个排序操作就分配一个临时段，可以采用以下方法创建临时表空间:<br />
(1)创建临时表空间<br />
如果在数据库运行过程中经常有大量排序工作要做，为了提高排序性能就应该建立多个链式表空间。<br />
CREATE SMALLFILE TEMPORARY TABLESPACE mytmptbs01 TEMPFILE
'e:\mytmptbs01_1.dbf' SIZE 4M UNIFORM SIZE 64K;<br />
必须用关键字TEMPFILE代替DATAFILE。另外，临时表空间使用临时文件而不是数据文件来创建。临时文件只能与临时表空间一起使用，不需要</p>
<p>备份，也不会把数据修改记录到重做日志中。<br />
在创建临时表空间时，区分配方式不能指定为AUTOALLOCATE方式，否则会出现错误提示。</p>
<p>(2)创建大文件临时表空间<br />
从ORACLE 10G开始，允许使用CREATE BIGFILE TEMPORARY
TABLESPACE命令来创建只包含一个临时文件的大文件临时表空间。<br />
CREATE BIGFILE TEMPORARY TABLESPACE mybigtmptbs02 TEMPFILE
'e:\mybigtmptbs02_1.dbf' SIZE 4M UNIFORM SIZE 64K;<br />
在创建临时表空间时，段管理方式不能指定为AUTO方式，否则会出现错误提示。</p>
<p>(四)创建撤销表空间<br />
撤销表空间(UNDO TABLESPACE)用户存储撤销段，该表空间只能使用本地管理方式。<br />
当执行CREATE
DATABASE语句创建数据库时，可以创建UNDO表空间，并且DBA可以使用该UNDO表空间来管理UNDO数据。创建数据库后，可以使用</p>
<p>CREATE UNDO TABLESPACE命令来创建UNDO表空间。<br />
CREATE UNDO TABLESPACE myundotbs01 DATAFILE 'e:\myundotbs01_1.dbf' SIZE
4M; AUTOALLOCATE;<br />
CREATE UNDO TABLESPACE myundotbs02 DATAFILE 'e:\myundotbs02_1.dbf' SIZE
4M AUTOEXTEND ON NEXT 1M MAXSIZE UNLIMITED;<br />
创建UNDO表空间时不能指定统一区大小的选项，否则会有错误提示。</p>
<p>如果想使用UNDO表空间的管理功能，就需要在初始化参数文件中设置如下参数：<br />
*.undo_management='AUTO'<br />
*.undo_tablespace='UNDOTBS1'<br />
其中，undo_management参数必须设置成AUTO，否则将使用回退表空间(ROLLBACK
TABLESPACE)；undo_tablespace参数用于指定要使用哪个UNDO</p>
<p>表空间。<br />
很显然可以创建多个UNDO表空间，但一次只能使用一个UNDO表空间。</p>
<p>可以用以下的语句修改初始化参数文件，就爱你个当前使用的UNDO表空间切换到另一个UNDO表空间。<br />
ALTER SYSTEM SET undo_tablespace='new_undo_tablespace' SCOPE=SPFILE;</p>
<p>当一个UNDO表空间切换到另一个UNDO表空间之后，就可以在前一个UNDO表空间中的活跃事务全部完成后删除就的表空间。<br />
可以修改UNDO表空间，如同增加一个数据文件、重新命名表空间、联机/脱机数据文件、备份表空间等。与其他表空间一样，正在使用的UNDO表</p>
<p>空间是不允许被删除的，即只有在其中已经没有未提交的事务时才能将其删除。<br />
可以用V$TRANSACTION视图来检查其中是否还有未提交的事务。</p>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328778.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:39 <a href="http://www.blogjava.net/gm_jing/articles/328778.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>管理表空间(前言)【引】</title><link>http://www.blogjava.net/gm_jing/articles/328776.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:38:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328776.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328776.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328776.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328776.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328776.html</trackback:ping><description><![CDATA[<div id="blog_text" class="cnt">
<p>表空间(TABLESPACE)是ORACLE数据库中最大的逻辑结构。ORACLE数据
库是由一个或多个表空间组成的。它在物理上与磁盘上的数据文件相对应(一个表空间由一个或多个数据文件组成，但一个数据文件只能属于一个表空间)。从物理
上说数据库的数据被存放在数据文件中，而从逻辑上说是被存放在表空间中的。<br />
数据库的逻辑配置实际上就是指表空间的配置。</p>
<p>一、表空间概述<br />
表空间是ORACLE数据库中最大的逻辑结构。数据库的所有对象和方案都被逻辑的保存在表空间中。</p>
<p>(一)表空间的特性与作用<br />
数据库管理系统(DBMS)是建立在操作系统(OS)基础上的，它的数据也必须存储在各个文件中，如数据文件、重做日志文件、归档日志文件等。<br />
表不是文件，表不是空间。<br />
表空间是组织结构和分配空间的逻辑结构。除了数据文件之外，控制文件、重做日志文件、归档日志文件等其他文件都不属于任何表空间。<br />
表空间的特性如下：<br />
1.一个数据库可以有多个表空间。可以在数据库中创建、删除表空间；<br />
2.一个表空间只属于一个数据库；<br />
3.一个表空间必须要有一个数据文件；<br />
4.一个表空间的大小等于其中所有数据文件的大小之和。数据库的大小等于其中所有表空间的大小之和；<br />
5.表空间可以被联机和脱机。SYSTEM表空间不能被脱机；<br />
6.表空间可以在读写、只读状态之间切换；<br />
7.每个表空间由一个或多个物理存在的操作系统的数据文件组成。这种数据文件可以具有固定的大小，或允许其自动变大。可以在表空间中添加、删除数据文件；<br />
8.方案对象、表、索引的数据都被存储在表空间的数据文件中。一个数据文件存储不下，就存储在另一个数据文件中，只要该数据文件是本表空间中的就可以；<br />
9.一个用户默认使用一个表空间，但他的不同方案对象的数据可以被存储在不同表空间中；<br />
10.一个用户使用的表空间的数量是有一定配额的，不能超出这个配额；<br />
11.可以根据使用目的，创建不同类型的表空间，如永久表空间、临时表空间、撤销表空间、大表空间等。不同类型的表空间的格式、使用方式及目的是不同的。</p>
<p>表空间的作用：<br />
1.控制数据库所占用的磁盘空间；<br />
2.控制用户所占用的表空间配额，也就等于控制用户所占用的配额空间；<br />
3.通过将不同表的数据、分区表中不同分区的数据放置到不同的表空间中，可以提高数据库的I/O性能，并有利于进行部分备份和恢复等管理工作；<br />
4.能够将一个表的数据和这个表的索引数据分别防止到不同的表空间中，同样可以提高数据库的I/O性能；<br />
5.可以将表空间设置成只读状态而保持大量的静态数据。</p>
<p>(二)表空间的类型<br />
一个数据库通常有SYSTEM,SYSAUX,TEMP三个默认表空间，一个或多个临时表空间，而且还有一个撤销表空间和几个应用程序专用的应用表空间。<br />
这些表空间可以划分为系统表空间和非系统表空间两类。<br />
系统数据(数组字典表及其数据) 系统表空间<br />
用户数据(表、索引) 大表空间、小表空间<br />
临时数据 临时表空间<br />
撤销数据 撤销表空间</p>
<p>(1)系统表空间<br />
系统表空间包括SYSTEM表空间和SYSAUX表空间，其余的表空间就是非系统表空间。系统表空间在所有数据库中都是必须的。一般存放到ORACLE的
数据字典及其数据。</p>
<p>(2)临时表空间<br />
撤了撤销(UNDO)表空间、相对于临时(TEMPORARY)空间而言，其他表空间就是永久(PERMANENT)表空间。<br />
当执行排序(ORDER BY)、分组汇总(GROUP BY)、索引(CREATE
INDEX)等功能的SQL语句时，会产生大量的临时数据。服务器进程首先将临时数据存放到内存结构的PGA区的排序区中，当排序区不够用时，服务器进程
就会在临时表空间中建立临时段，并将这些临时数据存放到临时段中。<br />
如果在创建用户时没有为用户指定一个临时表空间，那么就会使用SYSTEM表空间来说创建临时段，存放临时数据。这样做的结果是：<br />
1.占用了SYSTEM表空间的存储空间，使可用的存储空间下降；<br />
2.频繁的分配和释放临时段，会在SYSTEM表空间中产生大量的存储碎片，使磁盘的读取效率下降。</p>
<p>如果在数据运行过程中，经常有大量的并发排序，那么为了避免在SYSTEM表空间中存储临时数据，数据库管理员应该在数据库中创建一个专门的用来存
储临时数据的临时表空间。<br />
临时表空间对应的是临时文件，它与数据文件是有区别的。数据文件在创建时就被完全分配和初始化，而临时文件不一定保证被分配到指定的磁盘空间。如：在
UNIX操作系统中，将不实际分配临时文件的磁盘空间，而是知道某个操作需要临时表空间时才为临时文件分配磁盘空间。这种延迟式的分配方法允许临时文件被
快速创建，但如果没有预留出实际运行时所需的磁盘空间，就可能在运行时发生问题。<br />
临时表空间可以被所有用户共享使用，如TEMP表空间可以被所有用户共享使用。在ORACLE
8I中可以使用其他表空间作为临时表空间，而在ORACLE 9I中就开始引入默认临时表空间(DEFAULT TEMPORARY
TABLESPACE)的设计了，使用户不能使用其他表空间作为临时表空间。<br />
某个用户使用哪个临时表空间应该是在创建该用户时指定的。数据库的默认临时表空间是在创建(CREATE DATABASE)数据库时，由DEFAULT
TEMPORARY TABLESPACE子句来指定的。<br />
在临时表空间中，同一个例程的所有SQL语句的排序操作将共享使用一个排序段(SORT
SEGMENT)。排序段在执行第一条排序操作的SQL语句时被创建，在例程关闭时被释放。可以通过动态性能视图V$SORT_SEGMENT来查询排序
段的使用情况，通过动态性能视图V$SORT_USAGE来查询使用排序段的会话和用户信息。</p>
<p>(3)撤销表空间<br />
在ORACLE 9I以前，对于回退段(ROLLBACK SEGMENT)的设置与管理是一项十分复杂的工作。从ORACLE
9I开始，引入了一个全新的概念，即自动撤销管理(AUTOMATIC UNDO
MANAGEMENT)，用撤销(UNDO)表空间取代已经使用了20年的回退段。实际上是将回退段(撤销段)放入了撤销表空间，而由例程自动处理撤销表
空间中的回退段。使用自动撤销管理方式后，不仅可以减轻DBA的工作负担，而且还可以获得较好的回退性能。通过查询数据字典视图
DBA_ROLLBACK_SEGS，可以得到撤销表空间中回退段的信息。<br />
撤销表空间存储撤销段，撤销段主要用于入下目的:<br />
1.用一条ROLLBACK语句明确的回退一个事务；<br />
2.隐含的回退一个事务；<br />
3.重构数据的一个读一致图像；<br />
4.从逻辑错误中恢复。</p>
<p>在ORACLE中可以创建多个撤销表空间，但同一时刻值允许激活一个撤销表空间。在初始化参数文件中用UNDO_TABLESPACE指出要激活的
撤销表空间。撤销表空间的组织与管理由ORACLE内部自动完成。当回退段不足时，一个事务可以使用多个回退段，不会中止事务的运行。数据库管理员只需了
解撤销表空间是否有足够的空间，而不必为每个事务设置回退段。</p>
<p>(4)大文件表空间与小文件表空间<br />
大文件(BIGFILE)表空间是ORACLE
10G新引进的表空间。大文件表空间只能放置一个数据文件(或临时文件)。但其数据文件可以包括4G个数据块。<br />
大文件表空间都是为超大型数据库设计的。如果一个超大型数据库具有上千个数据文件的话，更新数据文件头部信息的操作就会花费很长时间。如果使用了
大文件表空间，就可以使用大数据文件来减少数据文件的数量，使更新数据文件头部信息的操作更快一些。<br />
要想创建一个大文件表空间，可以使用CREATE语句中的使用的BIGFILE关键字。CREATE BIGFILE TABLESPACE
mybigtbs01 DATAFILE 'e:\mybigtbs01_1.dbf' SIZE 20G SEGMENT SPACE
MANAGEMENT AUTO;<br />
小文件(SMALLFILE)表空间是以前ORACLE表空间的新命名。在小文件表空间中可以放置多个数据文件。一个数据库可以放置多达64K个数据文
件。<br />
SYSTEM和SYSAUX表空间总是被创建为小文件表空间。<br />
想要创建一个小文件表空间，可以在CREATE语句中使用SMALLFILE关键字(或者不适用此类关键字)。CREATE SMALLFILE
TEMPORARY TABLESPACE mytmptbs01 TEMPFILE 'e:\mytmptbs01_1.dbf' SIZE 4M
UNIFORM SIZE 64K;</p>
<p>(三)表空间的区、段管理方式<br />
ORACLE 10G的表空间是按照区和段空间进行管理的。<br />
(1)区管理方式<br />
针对区的分配方式不同，表空间有两种管理方式。ORACLE各个版本所支持的管理方式如下：<br />
字典管理方式 ORACLE 7,ORACLE 8,ORACLE 8I,ORACLE 9I;<br />
本地管理方式 ORACLE 8I,ORACLE 9I,ORACLE 10G;</p>
<p>字典管理方式(DICTIONARY-MANAGED TABLESPACE,DMT)<br />
字典管理方式是传统的管理方式，是为了与早期版本兼容而保留的区管理方式。在字典管理方式下，使用数据字典来管理存储空间的分配。<br />
当在表空间中分配新的区，或回收已分配的区时，ORACLE将对数据字典中的相关&#8220;基础表&#8221;进行查询、更新，并且在这一过程中，使用单线程搜索方法，速度
较慢。另外，对表的更新操作会产生会退信息和重做信息，因此，在分配区或回收区时，会在数据库中产生会退信息和重做信息。这是字典管理方式的特点，也是它
的缺点。<br />
在创建字典管理方式的表空间时，可以在DEFAULT
STORAGE子句中设置INITIAL,NEXT,MINEXTENTS,MAXENTENTS,PCTINCREASE等参数来为区设置存储管理方
式，以指定表空间中区的默认分配方式。这样，如果在这种表空间中创建表、索引等方案对象时，没有使用DEFAULT
STORAGE子句，他们就会自动继承表空间的存储参数设置。<br />
如果其他表空间要采用字典管理方式，则要求SYSTEM表空间也必须采用字典管理方式，并且必须在CREATE
TABLESPACE语句中显示的使用EXTENT MANAGEMENT
DICTIONARY子句进行申明。字典管理方式是被淘汰的表空间管理方式，从ORACLE 9I开始不再支持这种方式。</p>
<p>本地管理方式(LOCAL-MANAGED TABLESPACE,LMT)<br />
本地管理方式是一种新的、改进的管理方式。从ORACLE 9I开始，创建表空间时默认使用本地管理方式。<br />
本地管理方式下，表空间中分配与区回收的管理信息都被存储在表空间的数据文件中，而与数据字典无关。表空间会在每个数据文件中维护一个"位图
(BITMAP)"结构，用于记录表空间中所有区的分配情况。<br />
ORACLE为每个可能的区都保留了一位。该位为1或0，表示该区正在使用或空闲。位图图像消耗64KB的表空间。当在表空间中分配的区，或回收已分配的
区时，ORACLE将对数据文件中的"位图"进行更新。因此这种更新不是对表的更新操作，所以不会产生回退信息和重做信息。<br />
与字典管理方式相比，本地管理方式具有如下的好处：<br />
1.因为空间的分配和回收不需要对数据库进行访问，而只是简单的改变数据文件中的位图，所以能够提高空间存储管理的速度和并发性；<br />
2.能够避免在字典管理方式中空间分配期间可能出现的递归现象，所以提高了空间存储管理的性能。<br />
3.允许将数据库作为只读的备用数据库(STANDBY
DATABASE)。由于不会产生会退信息和重做信息，所以不会向数据库中写信息，这样就可以将整个数据库设置为只读状态。这种数据库可以作为备用数据
库。<br />
4.简化了空间分配，以为当指定了AUTOALLOCATE子句时，ORACLE会自动选择合适的区大小，不再需要用户进行任何干预；<br />
5.减少用户对数据库字典的依赖，因为必要的信息都被存储在数据文件的位图中了，而不是保存在数据字典中；<br />
6.不存在磁盘碎片问题。使用位图的方法去查询空闲空间，相邻的空闲块被视为一个大的空闲块，从设计上保证自动合并磁盘碎片，碎片产生后由系统自动消除；<br />
7.DBMS_SPACE_ADMIN包对本地管理的表空间提供维护过程。</p>
<p>在字典管理方式下，如果对某个表进行了更新，这时会产生存储管理操作，而该存储管理操作肯定会产生回退信息和重做信息，导致对回退段和重做日志文件
进行读写，从而又产生存储管理操作，形成了递归现象。<br />
在字典管理方式下，如果查询操作包含排序，则数据库需要为排序分配临时段，这会引起存储空间的分配操作，也就会对数据字典进行更新，所以数据库必须处于读
写状态，而不能处于只读状态。</p>
<p>在本地管理方式下，可以用以下两个选项来指定表空间的区的分配方式：<br />
1.
统一(UNIFORM)：统一分配，指定表空间中所有区的大小都相同。区的大小的默认值是1MB，也可以指定这个大小。但不能在撤销表空间中使用这个选
项；<br />
2.自动(AUTOALLOCATE或SYSTEM)自动分配，指定由ORACLE系统来自动管理区的大小，这是默认的设置。</p>
<p>在自动去的分配方式下，区的大小随表的大小自动动态改变，他们之间的对应关系如下：<br />
表大小&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  区大小<br />
64KB(或前16个区)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  64KB<br />
1MB(接下来的63个区)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  1MB<br />
64MB(接下来的120个区)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  8MB<br />
1000MB(以后的区)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;  64MB</p>
<p>当表的大小不超过64KB时，表空每个区的大小为64K；<br />
当表的大小不达到1MB时，表中每个区的大小为1MB；<br />
当表的大小超过64MB且小于1000MB时，区的大小都是8MB；当表的大小达到1000MB时，区的大小为64MB。<br />
也就是ishuo，这个算法只能使小表取小区，大表取大区，避免大表拥有过多的区。所以，自动选项最适合于由小表和大表构成的一个多用途的数据库系统。但
是，对于数据超过1GB的大表，系统在分配磁盘空间时一次分配64MB，如果所插入的数据没有达到64MB，则可能造成空间的浪费。<br />
通常，使用自动是最佳的选择。</p>
<p>(2)段空间管理方式<br />
在本地管理方式的表空间中，除了可以用UNIFORM和AUTOALLOCATE来指定区的分配方式之外，还可以指定段空间的管理方式。段空间管理方式主
要是指ORACLE用来管理段中已用数据块和空闲数据块的机制。<br />
在本地管理方式下，可以用如下两个关键字来指定表空间的段空间管理方式：<br />
1.MANUAL(手动)方式，这时ORACLE将使用空闲列表(FREE LIST)来管理段的空闲数据块。这是为了与以前的版本相兼容而保留的。<br />
2.AUTO(自动)方式，这时ORACLE将使用位图(BITMAP)来管理段的已用数据块和空闲数据块。即，通过位图中单元的取值来判断段汇总的数据
块是否可用。<br />
空闲列表(FREELIST)是传统的段空间管理方式，段中所有的空闲数据块都被放入一个空闲列表中，在需要存储空间时据在该列表中进行搜索。与空闲列表
相比，使用位图的自动方式能够提供更好的存储利用率。因为在自动方式下，用户不需要在创建方案对象时通过指定
PCTFREE,PCTUSED,FREELIST,FREELIST GROUP等参数来为段设置存储管理方式，即使设置了，也将会被忽略。<br />
当SYSTEM表空间的区管理方式是本地管理方式时则不可能创建字典管理的表空间，但可以创建本地管理的表空间。<br />
另外，创建表空间这种修改数据库物理结构的信息会同时被记录到预警日志文件中。</p>
<p>(四)表空间的状态<br />
处于不同状态的表空间，其使用方式有所不同。<br />
SYSTEM表空间不能被设置为只读状态或脱机状态，因为在数据库进行过程中始终会使用到SYSTEM表空间中的数据。<br />
(1)读写状态<br />
读写(READ-WRITE)<br />
默认情况下所有的表空间都是读写状态的。任何具有表空间配额并且具有适当权限的用户都可以读写该表空间中的数据。<br />
只读(READ-ONLY)<br />
如果将表空间设置为只读状态，则任何用户都无法向表空间中写入数据，也无法修改表空间中已有的数据。这种限制与用户的权限无关。将表空间设置为只读状态的
主要目的是，避免对数据库进行修改。使用户只能查询其中的数据，而不能修改其中的数据。同时，由于只读表空间中的数据不会被修改，因此DBA只需将只读表
空间备份一次即可，不必再次对这个表空间进行备份。如果数据库中保存大量的不允许用户修改、但又允许用户访问的数据。</p>
<p>(2)脱机状态<br />
通过将某个表空间设置为脱机状态，以使该表空间暂时不让用户访问。<br />
脱机模式有以下4种：<br />
1.正常(NORMAL)：默认的脱机模式。<br />
2.临时(TEMPORARY):<br />
3.立即(IMMEDIATE):<br />
4.用于恢复(FOR RECOVER):</p>
<p>二、管理表空间的准则</p>
<p>(一)确定表空间的大小</p>
<p>(1)确定表的大小</p>
<p>(2)确定表空间的大小</p>
<p>(二)表空间的配置</p>
<p>(1)表空间的层次结构</p>
<p>(2)表空间的分配</p>
<p>(三)为用户设置表空间配额和临时表空间</p>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328776.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:38 <a href="http://www.blogjava.net/gm_jing/articles/328776.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>创建用户并指定默认表空和默认临时表空间</title><link>http://www.blogjava.net/gm_jing/articles/328775.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Fri, 13 Aug 2010 06:37:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/328775.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/328775.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/328775.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/328775.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/328775.html</trackback:ping><description><![CDATA[<div id="blog_text" class="cnt">
<div class="blogstory">
<p>ORACLE创建用户并指定默认表空和默认临时表空间</p>
<p>//创建临时表空间</p>
<p>create temporary tablespace bocodbtempdbs <br />
tempfile 'D:\oracle\oradata\bocodb\bocodata\bocodbtempdbs01.dbf' <br />
size 32m <br />
autoextend on <br />
next 32m maxsize 2048m<br />
extent management local;</p>
<p>//创建数据表空间<br />
create tablespace bocodbdbs<br />
logging<br />
datafile 'D:\oracle\oradata\bocodb\bocodata\bocodbdbs.dbf' <br />
size 32m <br />
autoextend on <br />
next 32m maxsize 2048m<br />
extent management local;</p>
<p>//创建用户并指定表空间<br />
create user bocodb identified by bocodb<br />
default tablespace bocodbdbs<br />
temporary tablespace bocodbtempdbs;</p>
<p>//给用户授予权限</p>
<p>grant connect,resource to bocodb;</p>
</div>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/328775.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2010-08-13 14:37 <a href="http://www.blogjava.net/gm_jing/articles/328775.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>[引]事务的特性</title><link>http://www.blogjava.net/gm_jing/articles/298000.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Mon, 12 Oct 2009 14:55:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/298000.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/298000.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/298000.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/298000.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/298000.html</trackback:ping><description><![CDATA[<p class="g_p_center g_t_wrap g_t_left g_t_20 g_c_pdin c07" id="blogtitle_fks_087065093086084065086095081095086080086071083087080074" style="margin: 20px auto 10px"><span style="font-family: '微软雅黑','黑体',Arial,Helvetica,Sans-Serif">事务的特性(简称ACID)</span></p>
<div class="g_p_left">&nbsp;</div>
<div class="g_blog_list">
<div class="g_t_center g_c_pdin g_p_center c07 content" id="blogtext_fks_087065093086084065086095081095086080086071083087080074">
<div class="ns_content">
<p style="text-indent: 2em">数据库系统必须维护事务的以下特性(简称ACID)：</p>
<p style="text-indent: 2em">&nbsp;&nbsp;原子性(Atomicity)</p>
<p style="text-indent: 2em">&nbsp;&nbsp;一致性(Consistency)</p>
<p style="text-indent: 2em">&nbsp;&nbsp;隔离性(Isolation)</p>
<p style="text-indent: 2em">&nbsp;&nbsp;持久性(Durability)</p>
<p style="text-indent: 2em">原子性(Atomicity)</p>
<p style="text-indent: 2em">事务中的所有操作要么全部执行，要么都不执行；如果事务没有原子性的保证，那么在发生系统</p>
<p style="text-indent: 2em">故障的情况下，数据库就有可能处于不一致状态。</p>
<p style="text-indent: 2em">原子性(Atomicity)</p>
<p style="text-indent: 2em">如果故障发生在write(A)和read(B)之间，则将有可能造成帐户A的余额已经减去50元钱，而</p>
<p style="text-indent: 2em">帐户B的余额却没有改变，凭空就少了50元钱。值得注意的是，即使没有故障发生，系统在某</p>
<p style="text-indent: 2em">一时刻也会处于不一致状态。原子性的要求就是这种不一致状态除了在事务执行当中出现外，在其他任何时刻都是不可见的。保证原子性是DBMS的责任：即事务管理器和恢复管理器的责任。</p>
<p style="text-indent: 2em">一致性(Consistency)</p>
<p style="text-indent: 2em">主要强调的是，如果在执行事务之前数据库是一致的，那么在执行事务之后数据库也还是一</p>
<p style="text-indent: 2em">致的；所谓一致性简单地说就是数据库中数据的完整性，包括它们的正确性。对于图中的事务Ti来说，一致性要求就是事务的执行不改变帐户A和帐户B的和。否则的话事务就会创造或销毁钱！</p>
<p style="text-indent: 2em">单个事务的一致性是由对该事务进行编键的应用程序员的责任，但是在某些情况下利用DBMS中完整性约束(如触发器)的自动检查功能有助于一致性的维护。</p>
<p style="text-indent: 2em">隔离性(Isolation)</p>
<p style="text-indent: 2em">即使多个事务并发（同时）执行，每个事务都感觉不到系统中有其他的事务在执行，因而也就能保证数据库的一致性；</p>
<p style="text-indent: 2em">事情的起因:</p>
<p style="text-indent: 2em">即使每个事务都能保持一致性和原子性，但如果几个事务并发执行，且访问相同的数据项，则它们的操作会以人们所不希望的某种方式交叉执行，结果导致不一致的状态！访问相同数据项的两个事务并发执行</p>
<p style="text-indent: 2em"></p>
<p style="text-indent: 2em">解决办法:</p>
<p style="text-indent: 2em">如果几个事务要访问相同的数据项，为了保证数据库的一致性，可以让这几个事务：</p>
<p style="text-indent: 2em">①串行执行：即一个接着一个地执行事务；</p>
<p style="text-indent: 2em">②并发执行：即同时执行多个事务，但用并发</p>
<p style="text-indent: 2em">控制机制来解决不同事务间的相互影响。</p>
<p style="text-indent: 2em"></p>
<p style="text-indent: 2em">隔离性的保证:</p>
<p style="text-indent: 2em">事务的隔离性能够确保事务并发执行后的系统状态与这些事务按某种次序串行执行后的状态是等价的。保证隔离性也是DBMS的责任：即并发控制管理器的责任。</p>
<p style="text-indent: 2em">持久性(Durability)</p>
<p style="text-indent: 2em">事务成功执行后它对数据库的修改是永久的，即使系统出现故障也不受影响。持久性的含义是说：一旦事务成功执行之后，它对数据库的更新是永久的。可以用以下两种</p>
<p style="text-indent: 2em">方式中的任何一种来达到持久性的目的：</p>
<p style="text-indent: 2em">以牺牲应用系统的性能为代价</p>
<p style="text-indent: 2em">以多占用磁盘空间为代价</p>
<p style="text-indent: 2em">以牺牲应用系统的性能为代价：要求事务对数据库系统所做的更新在事务结束前已经写入磁盘；</p>
<p style="text-indent: 2em">以多占用磁盘空间为代价：要求事务已经执行的和已写到磁盘的、对数据库进行更新的信息是充分的（例</p>
<p style="text-indent: 2em">如，数据库日志的信息就足够的多），使得DBMS在系统出现故障后重新启动系统时，能够(根据日志)重</p>
<p style="text-indent: 2em">新构造更新。保证持久性也是DBMS的责任：即恢复管理器的责任。</p>
<p style="text-indent: 2em">事物的状态有如下几种：</p>
<p style="text-indent: 2em">⑴中止事务：执行中发生故障、不能执行完成的事务；</p>
<p style="text-indent: 2em">⑵事务回滚：将中止事务对数据库的更新撤消掉；</p>
<p style="text-indent: 2em">⑶已提交事务：成功执行完成的事务。</p>
<p style="text-indent: 2em">系统的恢复步骤是：</p>
<p style="text-indent: 2em">1、反向扫描文件日志（即从最后向前扫描日志文件），查找该事务的更新操作。</p>
<p style="text-indent: 2em">2、对该事务的更新操作执行逆操作。即将日志记录&#8220;更新前的值&#8221;写入数据库。这样，如果记录中是插入操作，则相当于做删除操作；若记录中是删除操作，则做插入操作；若是修改操作，则相当于用修改前的值代替修改后的值。</p>
<p style="text-indent: 2em">3、继续反向扫描日志文件，查找该事务的其他更新操作，并做和2一样的同样处理。</p>
<p style="text-indent: 2em">4、如此处理下去，直至读到此事务的开始标记，事务的故障恢复就完成了。</p>
<p style="text-indent: 2em">事务的隔离级别</p>
<p style="text-indent: 2em">隔离级别定义了事务与事务之间的隔离程度。</p>
<p style="text-indent: 2em">隔离级别与并发性是互为矛盾的：隔离程度越高，数据库的并发性越差；隔离程度越低，数据库的并发性越好。</p>
<p style="text-indent: 2em"></p>
<p style="text-indent: 2em">ANSI/ISO SQL92标准定义了一些数据库操作的隔离级别</p>
<p style="text-indent: 2em">&nbsp;&nbsp;未提交读（read uncommitted）</p>
<p style="text-indent: 2em">&nbsp;&nbsp;提交读（read committed）</p>
<p style="text-indent: 2em">&nbsp;&nbsp;重复读（repeatable read）</p>
<p style="text-indent: 2em">&nbsp;&nbsp;串行读（serializable）</p>
<p style="text-indent: 2em">隔离级别的效果</p>
<p style="text-indent: 2em">更新丢失（lost update）：当系统允许两个事务同时更新同一数据是，发生更新丢失。</p>
<p style="text-indent: 2em">脏读（dirty read）：当一个事务读取另一个事务尚未提交的修改时，产生脏读。</p>
<p style="text-indent: 2em">不可重复读取（nonrepeatableread）：同一查询在同一事务中多次进行，由于其他提交事务所做的修改</p>
<p style="text-indent: 2em">或删除，每次返回不同的结果集，此时发生不可重复读取。</p>
<p style="text-indent: 2em">幻像（phantom read）：同一查询在同一事务中多次进行，由于其他提交事务所做的插入操作，每次返回</p>
<p style="text-indent: 2em">不同的结果集，此时发生幻像读。</p>
</div>
</div>
</div>
<img src ="http://www.blogjava.net/gm_jing/aggbug/298000.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2009-10-12 22:55 <a href="http://www.blogjava.net/gm_jing/articles/298000.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>char varchar nvarchar varchar2 nvarchar2的区别</title><link>http://www.blogjava.net/gm_jing/articles/255120.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Tue, 17 Feb 2009 08:04:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/255120.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/255120.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/255120.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/255120.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/255120.html</trackback:ping><description><![CDATA[<p>【引】http://hi.baidu.com/zzuhpc/blog/item/b3c5c138f08ebcf53a87cec8.html<br />
1.char</p>
<p><wbr></wbr>char的长度是固定的，最大支持2000个字节。</p>
<p><wbr></wbr>char的长度是固定的，比如说，你定义了char(20),即使你你插入abc，不足二十个字节，数据库也会在abc后面自动加上17个空格，以补足二十个字节；</p>
<p><wbr></wbr>char是区分中英文的，中文在char中占两个字节，而英文占一个，所以char(20)你只能存20个字母或10个汉字。</p>
<p><wbr></wbr><font color="#ff0000">char适用于长度比较固定的，一般不含中文的情况</font></p>
<p><font color="#000000">2.varchar/varchar2</font></p>
<p><wbr></wbr>varchar是长度不固定的，最大支持4000个字节。</p>
<p><wbr></wbr>varchar是长度不固定的，比如说，你定义了varchar(20),当你插入abc，则在数据库中只占3个字节。</p>
<p><wbr></wbr>varchar同样区分中英文，这点同char。</p>
<p><wbr></wbr>varchar的效率低于char。</p>
<p><wbr></wbr>varchar2基本上等同于varchar，它是oracle自己定义的一个非工业标准varchar，不同在于，varchar2用null代替varchar的空字符串</p>
<p><wbr></wbr><font color="#ff0000">varchar/varchar2适用于长度不固定的，一般不含中文的情况</font></p>
<p><font color="#000000">3.nvarchar/nvarchar2</font></p>
<p><wbr></wbr>nvarchar和nvarchar2是长度不固定的</p>
<p><wbr></wbr>nvarchar不区分中英文，比如说：你定义了nvarchar(20),你可以存入20个英文字母/汉字或中英文组合，这个20定义的是字符数而不是字节数</p>
<p><wbr></wbr>nvarchar2基本上等同于nvarchar，不同在于nvarchar2中存的英文字母也占两个字节</p>
<p><wbr></wbr>nvarchar/nvarchar2适用于存放中文<br />
<br />
<br />
<br />
<hr />
<br />
orcale 中varchar2 和nvarchar2的区别<br />
在sql ref书中介绍到<br />
1 VARCHAR2(size)<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; [BYTE | CHAR]<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Variable-length character string having maximum<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; length size bytes or characters. Maximum size is<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 4000 bytes, and minimum is 1 byte or 1 character.<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; You must specify size for VARCHAR2.<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; BYTE indicates that the column will have byte<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; length semantics; CHAR indicates that the column<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; will have character semantics.<br />
1 NVARCHAR2(size) Variable-length character string having maximum<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; length size characters or bytes, depending on the<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; choice of national character set. Maximum size is<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; determined by the number of bytes required to store<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; each character, with an upper limit of 4000 bytes.<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; You must specify size for NVARCHAR2.<br />
中文大意：<br />
VARCHAR2(size)，可变长度的字符串，其最大长度为 size 个字节。size 的最大值是 4000，而最小值是 1。您必须指定一个 VARCHAR2 的 size。 <br />
NVARCHAR2(size)，可变长度的字符串，依据所选的国家字符集，其最大长度为 size 个字符或字节。size 的最大值取决于存储每个字符所需要的字节数，其上限为 4000 个字节。您必须为 NVARCHAR2 指定一个 size。 <br />
<br />
相同点：都是可变长度字符串(char类型是不变长度)，都必须指定大小<br />
不同点：VARCHAR2存放的英文字符只占一个字节，而nvarchar2依据所选的字符集，大多为两个<br />
</p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/255120.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2009-02-17 16:04 <a href="http://www.blogjava.net/gm_jing/articles/255120.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Union与Union All的区别 </title><link>http://www.blogjava.net/gm_jing/articles/237727.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Thu, 30 Oct 2008 17:21:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/237727.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/237727.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/237727.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/237727.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/237727.html</trackback:ping><description><![CDATA[<p>Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序；</p>
<p>Union All：对两个结果集进行并集操作，<strong>包括重复行</strong>，<strong>不进行排序</strong>；</p>
<p>Intersect：对两个结果集进行交集操作，不包括重复行，同时进行默认规则的排序；</p>
<p>Minus：对两个结果集进行差操作，不包括重复行，同时进行默认规则的排序。</p>
<p>可以在最后一个结果集中指定Order by子句改变排序方式。</p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/237727.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2008-10-31 01:21 <a href="http://www.blogjava.net/gm_jing/articles/237727.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>范式</title><link>http://www.blogjava.net/gm_jing/articles/138797.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Thu, 23 Aug 2007 05:03:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/138797.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/138797.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/138797.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/138797.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/138797.html</trackback:ping><description><![CDATA[1 第一范式（1NF） <br><br>在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。 <br><br>所谓第一范式（1NF）是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。在第一范式（1NF）中表的每一行只包含一个实例的信息。例如，对于图3-2 中的员工信息表，不能将员工信息都放在一列中显示，也不能将其中的两列或多列在一列中显示；员工信息表的每一行只表示一个员工的信息，一个员工的信息在表中只出现一次。简而言之，第一范式就是无重复的列。 <br><br>2 第二范式（2NF） <br><br>第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。如图3-2 员工信息表中加上了员工编号（emp_id）列，因为每个员工的员工编号是惟一的，因此每个员工可以被惟一区分。这个惟一属性列被称为主关键字或主键、主码。 <br><br>第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。 <br><br>3 第三范式（3NF） <br><br>满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如，存在一个部门信息表，其中每个部门有部门编号（dept_id）、部门名称、部门简介等信息。那么在图3-2的员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表，则根据第三范式（3NF）也应该构建它，否则就会有大量的数据冗余。简而言之，第三范式就是属性不依赖于其它非主属性。 <br>
<img src ="http://www.blogjava.net/gm_jing/aggbug/138797.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2007-08-23 13:03 <a href="http://www.blogjava.net/gm_jing/articles/138797.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>触发器</title><link>http://www.blogjava.net/gm_jing/articles/126506.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Wed, 27 Jun 2007 02:47:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/126506.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/126506.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/126506.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/126506.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/126506.html</trackback:ping><description><![CDATA[ORACLE产生数据库触发器的语法为：
<p>&#160;</p>
<p>&nbsp;&nbsp;&nbsp; create [or replace] trigger 触发器名 触发时间 触发事件</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; on 表名</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; [for each row]</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; pl/sql 语句</p>
<p>&nbsp;&nbsp;&nbsp; 其中：</p>
<p>&nbsp;&nbsp;&nbsp; 触发器名：触发器对象的名称。由于触发器是数据库自动执行</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 的，因此该名称只是一个名称，没有实质的用途。</p>
<p>&nbsp;&nbsp;&nbsp; 触发时间：指明触发器何时执行，该值可取：</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; before---表示在数据库动作之前触发器执行；</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; after---表示在数据库动作之后出发器执行。</p>
<p>&nbsp;&nbsp;&nbsp; 触发事件：指明哪些数据库动作会触发此触发器：</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; insert：数据库插入会触发此触发器；</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; update：数据库修改会触发此触发器；</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; delete：数据库删除会触发此触发器。</p>
<p>&nbsp;&nbsp;&nbsp; 表&nbsp;&nbsp;&nbsp; 名：数据库触发器所在的表。</p>
<p>&nbsp;&nbsp;&nbsp; for each row：对表的每一行触发器执行一次。如果没有这一</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 选项，则只对整个表执行一次。</p>
<p>&nbsp;&nbsp;&nbsp; 举例：下面的触发器在更新表auths之前触发，目的是不允许在</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 周末修改表：</p>
<p>&nbsp;&nbsp;&nbsp; create trigger auth_secure</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; before insert or update or delete&nbsp; //对整表更新前触发</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; on auths</p>
<p>&nbsp;&nbsp;&nbsp; begin</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if(to_char(sysdate,'DY')='SUN'</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; RAISE_APPLICATION_ERROR(-20600,'不能在周末修改表auths');</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; end if;</p>
<p>&nbsp;&nbsp;&nbsp; end<br><br><br><br>－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br>create trigger biufer_employees_department_id </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; before insert or u<a style="COLOR: #000000" href="http://digital.it168.com/files/zsxf.asp" target=_blank>pda</a>te </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; of department_id </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; on employees </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; referencing old as old_value </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; new as new_value </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for each row </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; when (new_value.department_id&lt;&gt;80 ) </p>
<p>　　begin </p>
<p>　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; :new_value.commission_<a style="COLOR: #000000" href="http://pc.it168.com/" target=_blank>pc</a>t :=0; </p>
<p>　　end; </p>
<p>　　/ </p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/126506.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2007-06-27 10:47 <a href="http://www.blogjava.net/gm_jing/articles/126506.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>存储过程</title><link>http://www.blogjava.net/gm_jing/articles/126039.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Mon, 25 Jun 2007 02:21:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/126039.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/126039.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/126039.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/126039.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/126039.html</trackback:ping><description><![CDATA[<p><span style="COLOR: #ff00ff">存储过程类似与我们编程时的函数,将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来, 那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令,跟函数调用差不多<span style="COLOR: #ff00ff"> </span>!</span><br><br>优点<br><br>1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。 <br>2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。 <br>3.存储过程可以重复使用,可减少数据库开发人员的工作量 <br>4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权</p>
<p>缺点 </p>
<p>１、如果逻辑全部在存储过程中实现，那么涉及广泛业务逻辑和处理的应用程序可能会给服务器带来过重负荷。这类处理包括数据传输、数据遍历、数据转换和大计算量操作。<br>应把这类处理移到业务过程或数据访问逻辑组件中，与数据库服务器相比，它们具有更好的可缩放性。<br>２、不要把所有业务逻辑都放在存储过程中。如果必须在 T - SQL 中修改业务逻辑，应用程序的维护和灵活性将成为问题。例如，支持多个 RDBMS 的 ISV 应用程序不应当<br>分别为每个系统维护存储过程。 通常，存储过程的编写与维护是一项专门技能，并非所有开发人员都能够掌握。这会造成项目开发计划的瓶颈。</p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/126039.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2007-06-25 10:21 <a href="http://www.blogjava.net/gm_jing/articles/126039.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>存储过程、函数在实际应用中有什么区别</title><link>http://www.blogjava.net/gm_jing/articles/125015.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Mon, 18 Jun 2007 15:18:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/125015.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/125015.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/125015.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/125015.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/125015.html</trackback:ping><description><![CDATA[<font face=Verdana>请问存储过程、函数在实际应用中有什么区别？</font>
<p><font face="verdana, arial, helvetica" size=2><span class=javascript id=text49806 style="FONT-SIZE: 12px">A stored procedure does something without returning a value while a function does something with a return value. There's no magic here. Any programming language is like this except some languages use different names from procedure / function.<br><br>In sqlplus,<br>To call a procedure<br>exec myproc(1,2,3)<br>To call a function<br>var a number<br>exec :a := myfunc(1,2,3)<br>assuming it returns a number, and both myproc and myfunc accept 3 arguments of type number<br></span></font></p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/125015.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2007-06-18 23:18 <a href="http://www.blogjava.net/gm_jing/articles/125015.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>数据库优化</title><link>http://www.blogjava.net/gm_jing/articles/124929.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Mon, 18 Jun 2007 05:56:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/124929.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/124929.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/124929.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/124929.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/124929.html</trackback:ping><description><![CDATA[<p><span>有什么方法优化</span><span>select</span><span>语句</span></p>
<p><span>参考答案：原则是避免全表扫描，</span></p>
<p><span>&nbsp;</span><span>如果是有多表关联的</span> <span>把记录数少的表放在前面，</span></p>
<p><span>&nbsp;</span><span>能把多的记录过虑的条件放在</span><span>where</span><span>从句前面，</span></p>
<p><span>&nbsp;</span><span>用</span><span>exist</span><span>代替</span><span>in</span><span>条件</span></p>
<p><span>&nbsp;</span><span>尽可能用索引</span></p>
<p>&nbsp;</p>
<p><span>select</span><span>索引什么时候失效</span></p>
<p><span>参考答案：索引的字段在</span><span>sum</span><span>等函数中时</span><span> <br />
<br />
------------------------------------------------<br />
用exists代替in<br />
SELECT * <br />
FROM EMP (基础表) <br />
WHERE EMPNO &gt; 0 <br />
AND DEPTNO IN (SELECT DEPTNO <br />
FROM DEPT <br />
WHERE LOC = &#8216;MELB') <br />
<br />
高效exists: <br />
SELECT * <br />
FROM EMP (基础表) <br />
WHERE EMPNO &gt; 0 <br />
AND EXISTS (SELECT &#8216;X' <br />
FROM DEPT <br />
WHERE DEPT.DEPTNO = EMP.DEPTNO <br />
AND LOC = &#8216;MELB') <br />
</span></p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/124929.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2007-06-18 13:56 <a href="http://www.blogjava.net/gm_jing/articles/124929.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>数据库中大字段的处理</title><link>http://www.blogjava.net/gm_jing/articles/76170.html</link><dc:creator>黎夕</dc:creator><author>黎夕</author><pubDate>Thu, 19 Oct 2006 07:10:00 GMT</pubDate><guid>http://www.blogjava.net/gm_jing/articles/76170.html</guid><wfw:comment>http://www.blogjava.net/gm_jing/comments/76170.html</wfw:comment><comments>http://www.blogjava.net/gm_jing/articles/76170.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/gm_jing/comments/commentRss/76170.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/gm_jing/services/trackbacks/76170.html</trackback:ping><description><![CDATA[
		<p>
				<font size="2">[引用]http://www.javaeye.com/article/27917</font>
				<br />
				<br />在数据库中，经常需要用到大字段类型，如oracle中long/blob/clob,sqlserver中text/image，mysql中的text/longtext/clob/blob。 <br />存储的信息大概主要是两类，一类是长文本，如大段的文字，普通的varchar最长只能存储4000个汉字，已经不能满足要求；另一类是存储二进制信息，如上传的文件等。 <br />那么假如现在有一个表，记录某人发布的文档信息，字段包括：发布人，发布时间，文档标题，文档内容(实际中还会有其它字段)，一般建表如下(sqlserver)： <br />create table document( <br />id int identity(1,1) not null, <br />createuser_id int, <br />document_title varchar(255), <br />document_context text);</p>
		<p>这张表的结构，表面上看起来，从数据库设计角度和对应的JAVA类的设计来讲，都是没有问题的。</p>
		<p>但实际上，这里面隐藏着两个比较严重的问题！</p>
		<p>
				<b>一、不能完全跨数据库</b>
				<br />why?问题出在需要查重(distinct)的时候。 <br />在需要查重时，采用纯jdbc技术，则可以自定义要查重的字段，如select distinct id,createuser_id,document_title from document。而当采用hibernate时，若不想自已创建若干个新的Pojo或者使用Object[]方式来处理数据，则只能使用select distinct d from document as d这样的语句，而hibernate会将其解析为类似：select distinct id,createuser_id,document_title,document_context from document。 <br />问题就出在这个document_context字段上！ <br />对于oracle/mysql来讲，hibernate生成的sql是可以执行的。但对于sqlserver来讲，是不允许在text/image列上进行distinct查询的！ <br />因此系统在sqlserver上部署时，当需要查重时则会出错。 <br />我也是在开发一个系统即将完成的时候，在sqlserver上部署才发现的该问题，最后修改了所有类似的Pojo和表结构以及DAO，相关的显示层代码也进行了修改。工程量可谓不小。当然如果你用不到查重语句，是一点不受影响的。 <br /><b>二、严重影响列表显示和统计的效率</b><br />影响一张表的查询速度的，除了行数，还包括表所占的物理空间的大小。此表在数据量较小时，在查询方面感觉不到明显的差异。但是如果document_context字段所存储的数据都是大段文本或较大的文件时，会导致表的物理空间迅速变大，该字段所占用的空间有可能达到整表所占空间的90%以上。在此基础上，如果行数再增加到数十万、上百万级时，整个表所占的空间将达到一个惊人的数字。 <br />保守估计，一条记录占用的空间平均为10K的话，一万条记录将占用100M的空间，一百万条记录将占用10G！在此表上的CRUD操作，亦将变慢，查询的速度亦会受到非常大的影响 。当然通过提高服务器本身的硬件性能和优化索引，可以提高查询速度，但面对无法预知的巨大洪水，单纯加固堤坝是不保险的。</p>
		<p>
				<b>解决的方式？</b>
				<br />曾经处理过公司内的一个老系统，表的行数达到十万左右，由于采用上面的设计方式，虽然已经尽可能优化了索引，但查询分页时，仍然需要十秒左右。我单独建了一个新表，将document_context这个字段移到新表中，在原表中加一个对应的外键列，经过处理后，分页显示响应时间降到毫秒级以内。（二进制数据的转移是无法使用普通 的数据导入导出方式的，我的方法是复制该表，然后再修改复制后的表结构） <br />因为这个大字段，在最常用的列表显示中是根本不需要关心的，仅当用户需要查看某一记录的具体信息时，才需要调入该字段信息。因此分表后，显著提高了分页性能。</p>
		<p>在我现在开发的所有的系统中，我都采用了上述的方式，这样做属于未雨绸缪，一旦系统部署后再修改，可能就来不及了。</p>
<img src ="http://www.blogjava.net/gm_jing/aggbug/76170.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/gm_jing/" target="_blank">黎夕</a> 2006-10-19 15:10 <a href="http://www.blogjava.net/gm_jing/articles/76170.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>