﻿<?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-思想比知识更重要 成长比成功更重要-随笔分类-DB</title><link>http://www.blogjava.net/renyangok/category/17013.html</link><description /><language>zh-cn</language><lastBuildDate>Wed, 02 Jan 2008 16:32:20 GMT</lastBuildDate><pubDate>Wed, 02 Jan 2008 16:32:20 GMT</pubDate><ttl>60</ttl><item><title>数据库事务隔离知识</title><link>http://www.blogjava.net/renyangok/archive/2007/12/29/171528.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Sat, 29 Dec 2007 06:40:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2007/12/29/171528.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/171528.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2007/12/29/171528.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/171528.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/171528.html</trackback:ping><description><![CDATA[推荐：PostgreSQL 8.1 中文文档12.2. 事务隔离：<br />
http://www.itworld21.com/docs/db/postgresql8.1/transaction-iso.html<br />
<br />
难点：不可重复读和幻读的区别：<br />
不可重复读的重点是修改:<br />
同样的条件,&nbsp;&nbsp; 你读取过的数据,&nbsp;&nbsp; 再次读取出来发现值不一样了<br />
幻读的重点在于新增或者删除<br />
同样的条件,&nbsp;&nbsp; 第1次和第2次读出来的记录数不一样<br />
<br />
当然,&nbsp;&nbsp; 从总的结果来看,&nbsp;&nbsp; 似乎两者都表现为两次读取的结果不一致.<br />
但如果你从控制的角度来看,&nbsp;&nbsp; 两者的区别就比较大<br />
对于前者,&nbsp;&nbsp; 只需要锁住满足条件的记录<br />
对于后者,&nbsp;&nbsp; 要锁住满足条件及其相近的记录<br />
<img src ="http://www.blogjava.net/renyangok/aggbug/171528.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2007-12-29 14:40 <a href="http://www.blogjava.net/renyangok/archive/2007/12/29/171528.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>数据库外键， 用还是不用？</title><link>http://www.blogjava.net/renyangok/archive/2007/12/29/171492.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Sat, 29 Dec 2007 05:16:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2007/12/29/171492.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/171492.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2007/12/29/171492.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/171492.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/171492.html</trackback:ping><description><![CDATA[对于主/外键/索引来说，在一些开发团队中被认为是处理数据库关系的利器，也被某些开发团队认为是处理某些具体业务的魔鬼，您的观点呢？在实际应用中您会采取哪种方式？<br />
<br />
大家共同观点：<br />
主键和索引是不可少的，不仅可以优化数据检索速度，开发人员还省不其它的工作, <br />
<br />
矛盾焦点：数据库设计是否需要外键。这里有两个问题：一个是如何保证数据库数据的完整性和一致性；二是第一条对性能的影响。<br />
<br />
正方观点：<br />
1，由数据库自身保证数据一致性，完整性，更可靠，因为程序很难100％保证数据的完整性，而用外键即使在数据库服务器当机或者出现其他问题的时候，也能够最大限度的保证数据的一致性和完整性。<br />
eg：数据库和应用是一对多的关系，Ａ应用会维护他那部分数据的完整性，系统一变大时，增加了Ｂ应用，Ａ和Ｂ两个应用也许是不同的开发团队来做的。他们如何协调保证数据的完整性，而且一年以后如果又增加了C应用呢？ <br />
2，有主外键的数据库设计可以增加ER图的可读性，这点在数据库设计时非常重要。<br />
3，外键在一定程度上说明的业务逻辑，会使设计周到具体全面。<br />
<br />
反方观点：<br />
1，可以用触发器或应用程序保证数据的完整性<br />
2，过分强调或者说使用主键／外键会平添开发难度，导致表过多等问题<br />
3，不用外键时数据管理简单，操作方便，性能高（导入导出等操作，在insert,&nbsp;&nbsp; update,&nbsp;&nbsp; delete&nbsp;&nbsp; 数据的时候更快）<br />
eg:在海量的数据库中想都不要去想外键，试想，一个程序每天要insert数百万条记录，当存在外键约束的时候，每次要去扫描此记录是否合格，一般还不止一个字段有外键，这样扫描的数量是成级数的增长！我的一个程序入库在3个小时做完，如果加上外键，需要28个小时！&nbsp;&nbsp; <br />
<br />
结论：<br />
1，在大型系统中（性能要求不高，安全要求高），使用外键；在大型系统中（性能要求高，安全自己控制），不用外键；小系统随便，最好用外键。<br />
2，用外键要适当，不能过分追求<br />
3，不用外键而用程序控制数据一致性和完整性时，应该写一层来保证，然后个个应用通过这个层来访问数据库。<br />
<img src ="http://www.blogjava.net/renyangok/aggbug/171492.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2007-12-29 13:16 <a href="http://www.blogjava.net/renyangok/archive/2007/12/29/171492.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>postgresql学习笔记</title><link>http://www.blogjava.net/renyangok/archive/2007/05/22/119188.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Tue, 22 May 2007 09:40:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2007/05/22/119188.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/119188.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2007/05/22/119188.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/119188.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/119188.html</trackback:ping><description><![CDATA[1，一次插入多条数据：<br />
/* add some test users for authorization project */ <br />
COPY bo_users (id, name, username, "password", active, closed, created, "admin", roles, nordicbet, triobet, pamebet, email, livescore) FROM stdin; <br />
100&nbsp;&nbsp;&nbsp;&nbsp; Support support_user&nbsp;&nbsp;&nbsp; 202cb962ac59075b964b07152d234b70&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2004-01-01 00:00:00&nbsp;&nbsp;&nbsp;&nbsp; 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Manager t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; support_user@example.com&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f <br />
101&nbsp;&nbsp;&nbsp;&nbsp; Finance finance_user&nbsp;&nbsp;&nbsp; 202cb962ac59075b964b07152d234b70&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2004-01-01 00:00:00&nbsp;&nbsp;&nbsp;&nbsp; 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Manager t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; finance_user@example.com&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f <br />
102&nbsp;&nbsp;&nbsp;&nbsp; Marketing&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; marketing_user&nbsp; 202cb962ac59075b964b07152d234b70&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2004-01-01 00:00:00&nbsp;&nbsp;&nbsp;&nbsp; 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Manager t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; marketing_user@example.com&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f <br />
103&nbsp;&nbsp;&nbsp;&nbsp; Security&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; security_user&nbsp;&nbsp; 202cb962ac59075b964b07152d234b70&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 2004-01-01 00:00:00&nbsp;&nbsp;&nbsp;&nbsp; 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Manager t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; security_user@example.com&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; f <br />
<br />
2,<br />
\d&nbsp;&nbsp; ——列出所有关系<br />
\l&nbsp;&nbsp;&nbsp; ——列出所有数据库<br />
&nbsp;\d{t|i|s|v|S} ——列出 tables/indexes/sequences/views/system tables<br />
\?&nbsp;&nbsp; ——帮助<br />
<br />
3，拷贝一个表的内容进入另一个表<br />
<ins>/* Copy the old users_season_risk to users_category_risk. */</ins><br />
select * into users_category_risk from users_season_risk;<br />
<br />
4，远程访问数据库<br />
psql -h &lt;host&gt; -U &lt;用户名&gt; -D &lt;数据库名&gt;<br />
note：其他如端口，密码等看help<br />
<br />
5，导数据库（eg：把forge上NBET的users表倒到本地）<br />
pg_dump -h forge NBET -t users &gt; test.dump<br />
psql NBET &lt; test.dump<br />
<img src ="http://www.blogjava.net/renyangok/aggbug/119188.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2007-05-22 17:40 <a href="http://www.blogjava.net/renyangok/archive/2007/05/22/119188.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>MySQL与PostgreSQL比较</title><link>http://www.blogjava.net/renyangok/archive/2007/04/24/113263.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Tue, 24 Apr 2007 09:10:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2007/04/24/113263.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/113263.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2007/04/24/113263.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/113263.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/113263.html</trackback:ping><description><![CDATA[<span class="oblog_text"><span style="color: black; font-family: 宋体;">（转自：http://www.blogchinese.com/06042/201878/archives/2006/200687202945.shtml，从熟悉和不熟悉的同一类东西的比较中了解不熟悉的是个好方法（有点绕，呵呵），我就是从这篇文章了解PostgreSQL的）<br>
<br>
这篇文章中，我们选用<span xml:lang="EN-US" lang="EN-US">MySQL
4.0.2-alpha与PostgreSQL 7.2进行比较，因为MySQL
4.0.2-alpha开始支持事务的概念，因此这样的比较对于MySQL应该较为有利。<br>
我们这样的比较不想仅仅成为一份性能测试报告，因为至少从我个人来看，对于一个数据库，稳定性和速度并不能代表一切。对于一个成熟的数据库，稳定性肯定会日益提供。而随着硬件性能的飞速提高，速度也不再是什么太大的问题。<br>
<br>
<strong>一、两者的共同优势</strong><br>
这两个产品都属于开放源码的一员，性能和功能都在高速地提高和增强。MySQL
AB的人们和PostgreSQL的开发者们都在尽可能地把各自的数据库改得越来越好，所以对于任何商业数据库使用其中的任何一个都不能算是错误的选择。<br>
<br>
<strong>二、两者不同的背景</strong><br>
MySQL的背后是一个成熟的商业公司，而PostgreSQL的背后是一个庞大的志愿开发组。这使得MySQL的开发过程更为慎重，而PostgreSQL的反应更为迅速。<br>
这样的两种背景直接导致了各自固有的优点和缺点。<br>
<br>
<strong>三、MySQL的主要优点</strong><br>
1、首先是速度，MySQL通常要比PostgreSQL快得多。MySQL自已也宣称速度是他们追求的主要目标之一，基于这个原因，MySQL在以前
的文档中也曾经说过并不准备支持事务和触发器。但是在最新的文档中，我们看到MySQL
4.0.2-alpha已经开始支持事务，而且在MySQL的TODO中，对触发器、约束这样的注定会降低速度的功能也列入了日程。但是，我们仍然有理由
相信，MySQL将有可能一直保持速度的优势。<br>
2、MySQL比PostgreSQL更流行，流行对于一个商业软件来说，也是一个很重要的指标，流行意味着更多的用户，意味着经受了更多的考验，意味着更好的商业支持、意味着更多、更完善的文档资料。<br>
3、与PostgreSQL相比，MySQL更适宜在Windows环境下运行。MySQL作为一个本地的Windows应用程序运行(在
NT/Win2000/WinXP下，是一个服务)，而PostgreSQL是运行在Cygwin模拟环境下。PostgreSQL在Windows下运
行没有MySQL稳定，应该是可以想象的。<br>
4、MySQL使用了线程，而PostgreSQL使用的是进程。在不同线程之间的环境转换和访问公用的存储区域显然要比在不同的进程之间要快得多。<br>
5、MySQL可以适应24/7运行。在绝大多数情况下，你不需要为MySQL运行任何清除程序。PostgreSQL目前仍不完全适应24/7运行，这是因为你必须每隔一段时间运行一次VACUUM。<br>
6、MySQL在权限系统上比PostgreSQL某些方面更为完善。PostgreSQL只支持对于每一个用户在一个数据库上或一个数据表上的
INSERT、SELECT和UPDATE/DELETE的授权，而MySQL允许你定义一整套的不同的数据级、表级和列级的权限。对于列级的权限，
PostgreSQL可以通过建立视图，并确定视图的权限来弥补。MySQL还允许你指定基于主机的权限，这对于目前的PostgreSQL是无法实现
的，但是在很多时候，这是有用的。<br>
7、由于MySQL
4.0.2-alpha开始支持事务的概念，因此事务对于MySQL不再仅仅成为劣势。相反，因为MySQL保留无事务的表类型。这就为用户提供了更多的选择。<br>
8、MySQL的MERGE表提供了一个独特管理多个表的方法。<br>
9、MySQL的myisampack可以对只读表进行压缩，此后仍然可以直接访问该表中的行。<br>
<br>
<strong>四、PostgreSQL的主要优点：</strong><br>
1、对事务的支持与MySQL相比，经历了更为彻底的测试。对于一个严肃的商业应用来说，事务的支持是不可或缺的。<br>
2、MySQL对于无事务的MyISAM表。采用表锁定，一个长时间运行的查询很可能会长时间地阻碍对表的更新。而PostgreSQL不存在这样的问题。<br>
3、PostgreSQL支持存储过程，而目前MySQL不支持，对于一个严肃的商业应用来说，作为数据库本身，有众多的商业逻辑的存在，此时使用存储
过程可以在较少地增加数据库服务器的负担的前提下，对这样的商业逻辑进行封装，并可以利用数据库服务器本身的内在机制对存储过程的执行进行优化。此外存储
过程的存在也避免了在网络上大量的原始的SQL语句的传输，这样的优势是显而易见的。<br>
4、对视图的支持，视图的存在同样可以最大限度地利用数据库服务器内在的优化机制。而且对于视图权限的合理使用，事实上可以提供行级别的权限，这是MySQL的权限系统所无法实现的。<br>
5、对触发器的支持，触发器的存在不可避免的会影响数据库运行的效率，但是与此同时，触发器的存在也有利于对商业逻辑的封装，可以减少应用程序中对同一商业逻辑的重复控制。合理地使用触发器也有利于保证数据的完整性。<br>
6、对约束的支持。约束的作用更多地表现在对数据完整性的保证上，合理地使用约束，也可以减少编程的工作量。<br>
7、对子查询的支持。虽然在很多情况下在SQL语句中使用子查询效率低下，而且绝大多数情况下可以使用带条件的多表连接来替代子查询，但是子查询的存在在很多时候仍然不可避免。而且使用子查询的SQL语句与使用带条件的多表连接相比具有更高的程序可读性。<br>
8、支持R-trees这样可扩展的索引类型，可以更方便地处理一些特殊数据。<br>
9、PostgreSQL可以更方便地使用UDF(用户定义函数)进行扩展。<br>
<br>
<strong>五、那么我究竟应该使用MySQL还是PostgreSQL</strong><br>
这个问题很难说得清，而且事实上除了MySQL和PostgreSQL外，使用Oracle、Sybase、Informix等也是明智的选择。如何你确定只在MySQL和PostgreSQL中进行选择，以下规则总是有效的。<br>
1、如果你的操作系统是Windows，你应该使用MySQL。<br>
2、如果你对数据库并不了十分了解，甚至不知道事务、存储过程等究竟是什么，你应该使用MySQL。<br>
3、如果你的应用对数据的完整性和严肃性要求不高，但是追求处理的高速度。例如是一个论坛和社区，你应该使用MySQL。<br>
4、你的应用是一个严肃的商业应用，对数据完整性要求很高。而且你希望对一些商业数据逻辑进行很好的封装，例如是一个网上银行，你应该使用PostgreSQL。<br>
5、你的应用处理的是地理数据，由于R-TREES的存在，你应该使用PostgreSQL。<br>
6、你是一个数据库内核的狂热爱好者，你甚至希望拥有你自己版本的数据库，毫无疑问，你必须使用PostgreSQL，没准下一个PostgreSQL版本中某一个模块的作者就是你。<br>
<br>
<span>&nbsp;&nbsp;&nbsp;</span>
<strong>后记</strong><br>
以上只是作者从自己的理解尽量客观公正地评价MySQL和PostgreSQL的优劣。其中的带有倾向性的意见只代表作者个人观点，有关这两个数据库，欢迎广大朋友提出自己的看法</span></span></span><img src ="http://www.blogjava.net/renyangok/aggbug/113263.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2007-04-24 17:10 <a href="http://www.blogjava.net/renyangok/archive/2007/04/24/113263.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>LDAP简介：什么是目录</title><link>http://www.blogjava.net/renyangok/archive/2006/12/14/87621.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Thu, 14 Dec 2006 01:30:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/12/14/87621.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/87621.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/12/14/87621.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/87621.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/87621.html</trackback:ping><description><![CDATA[
		<table cellspacing="0" cellpadding="0" width="90%" align="center" border="0">
				<tbody>
						<tr>
								<th class="f24">
										<h1 align="center">
												<font size="2">LDAP简介：什么是目录 </font>
										</h1>
								</th>
						</tr>
						<tr>
								<td align="middle" height="20">
										<small>本文出自:http://www.china-pub.com 作者: 应雷 (2001-08-12 09:05:01)</small>
										<font size="2">
										</font>
								</td>
						</tr>
						<tr>
								<td>
										<font size="2">
												<script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript">
												</script>
										</font>
								</td>
						</tr>
						<tr>
								<td height="15">
										<font size="2">
										</font>
								</td>
						</tr>
						<tr>
								<td class="l17">
										<font class="f14" id="zoom">
												<!-- 正文begin -->
												<font size="2">一、 大纲和目标 <br /><br />此文为理解什么是LDAP打下一个基础。目标是使你掌握基本的术语和概念，不作为深入学习LDAP的材料。LDAP，它的 <br />全称为轻量级目录访问协议。 <br /><br />此文包括以下几方面的内容： <br />* 目录的基本定义 <br />* 理解目录能做什么和不能做什么 <br />* 2个目录例子 <br />* 总结使用目录服务的校验表 <br /><br />二、 基本定义 <br /><br />目录是一种专门的数据库，它服务于各种应用程序，包括LDAP（轻量级目录访问协议）目录和基于X.500的目录。这些 <br />目录都是通用的标准的目录。它们不适合于特定的操作系统、应用目的。 <br /><br />不管她们知不知道这里的目录是什么意思，大多数人熟悉各种各样的目录，像电话簿、黄页，电视指南、购物目录和图 <br />书馆卡片目录。我们把这一类目录归为日常目录。在计算机中的目录被称为在线目录。 <br /><br />目录服务是软件、硬件、策论以及管理的集合体。目录服务至少包括以下几个方面： <br />* 包含在目录中的信息 <br />* 保存信息的软件服务端 <br />* 扮演存取信息的软件客户端 <br />* 跑服务端，客户端软件的硬件 <br />* 支撑系统，像操作系统、设备驱动等 <br />* 连接客户端到服务端以及各个服务端之间的网络基础设施 <br />* 策略。规定谁能访问，谁能更新，谁能存取等 <br />* 维护和监视目录服务的软件 <br /><br />术语目录和目录服务经常可换用。 <br /><br />三、 目录是什么以及它能做什么 <br /><br />下面的应用类型不能被归为目录： <br />* 数据库 <br />* 文件系统 <br />* web服务 <br />* FTP服务 <br />* DNS服务 <br /><br />与数据库比较 <br /><br />虽然目录也被称为特殊的数据库，但它不同于真正的数据库。目录的大部分操作为读操作。假如你的应用程序要写大 <br />量的数据，你应该考虑选择使用数据库来实现。目录支持相对简单的事务处理。相反，数据库被设计成处理大量的各 <br />种各样的事务处理。假如你的应用要求这种重负荷的事务支持，你该选择数据库而不是目录。 <br /><br />在另一方面，假如你的应用不要求这样的大负荷事务处理，而是偶尔的写一些简单的事务信息。这时，目录是理想的 <br />选择。它会更有效，更简单。 <br /><br />与文件系统比较 <br /><br />目录被认为是很差的文件系统。文件通常很大，有几兆甚至更大，虽然目录被优化成存取很小的信息。应用程序以块 <br />的方式存取文件。文件系统支持各种调用--像seek()，read()和write()，这样可以写大文件的一部分的信息。目录 <br />不能提供这种随机的存取访问。目录条目被分成各种属性。你可以分别获取各种属性。你不能取得一个条目的部分值， <br />如从第几个字节开始。 <br /><br />与web的比较 <br /><br />不象web服务器一样，目录不适合推送JPEG图象或Java程序给客户端。Web服务通常作为开发web应用的跳板。这些平 <br />台从CGI（公用网关接口）到更复杂的像Netscape应用服务平台。目录一般不提供这种形式的应用开发，甚至它不提 <br />供目录应用开发平台服务。 <br /><br />与FTP比较 <br /><br />与FTP的主要区别在于：数据量的大小和客户的类型。另外一点就是FTP是一个非常简单的协议，它专于做一件事情并 <br />把它做好。假如你想做的是把文件从一个地方传送到另一个地方，那么额外的目录下层结构也需要，如复制、查询、 <br />更新等。 <br /><br />与DNS比较 <br /><br />因特网的域名系统和目录有相似之处，它们都提供对分层式数据库的访问。但其它一些不同把它们区分开来。 <br /><br />DNS的主要目的是把主机名转换成IP地址。比较而言，大多数目录有更普通的作用。DNS有一套专门的、固定的计划， <br />而目录允许被扩展。DNS不允许更新它的信息，而目录可以。DNS可通过UDP的无连接的方式访问，而目录通常是连接 <br />访问的。 <br /><br />四、 目录举例 <br /><br />X.500 <br /><br />在八十年代中期，两个不同的团体--CCITT和ISO，各自开始在目录服务方面的研究工作。最后，两个国际性的目录规 <br />范融合成一个规范，这就是X.500。X.500的优势在于它的信息模型，它的多功能性和开放性。 <br /><br />LDAP <br /><br />1993年7月，第一个LDAP规范是由密歇根大学开发的，也就是RFC1487。LDAP的开发者们简化了笨重的X.500目录访问 <br />协议，他们在功能性、数据表示、编码和传输方面做了改建。目前，LDAP的版本是第3版本，相对以前版本来说， <br />第3版本在国际化、提名、安全、扩展性和特性方面更加完善。1997年，第3版本成为因特网标准。 <br /><br />五、 目录服务校验表 <br /><br />下面是简要的总结：为你是否选择目录或其它技术提供导航。 <br />* 信息量大小。目录适合于存放相对小的信息量，而不是几兆大小的文件。可以利用指针，它可以指向大的文件， <br />但绝不是文件本身。 <br />* 信息的类型。目录通常是基于属性的信息。 <br />* 读写比。目录适合于读操作更多的应用。如需要用到大量的写操作，数据库是一个选择。 <br />* 搜寻能力。目录能搜寻他自身包含的信息。 <br />* 标准访问。假如你需要标准的访问信息。目录是一个好的选择。 <br /><br />六、 参考文献 <br /><br />X.500 Lightweight Directory Access Protocol <br />http://www.cis.ohio-state.edu/rfc/rfc1487.txt <br /><br />A String Representation of LDAP Search Filters <br />http://www.cis.ohio-state.edu/rfc/rfc1558.txt <br /><!-- 正文end --><br />(http://www.fanqiang.com)<br /></font>
										</font>
								</td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.blogjava.net/renyangok/aggbug/87621.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-12-14 09:30 <a href="http://www.blogjava.net/renyangok/archive/2006/12/14/87621.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>MS SQLSERVER中如何快速获取表的记录总数 </title><link>http://www.blogjava.net/renyangok/archive/2006/12/01/84745.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Fri, 01 Dec 2006 01:57:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/12/01/84745.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/84745.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/12/01/84745.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/84745.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/84745.html</trackback:ping><description><![CDATA[（转自：<a href="http://www.cnblogs.com/pingkeke/archive/2006/05/29/411995.html">http://www.cnblogs.com/pingkeke/archive/2006/05/29/411995.html</a>）<br />在数据库应用的设计中，我们往往会需要获取某些表的记录总数，用于判断表的记录总数是否过大，是否需要备份数据等。我们通常的做法是：select count(*) as c from tableA 。然而对于记录数巨大的表，上述做法将会非常耗时。在DELL 4400 服务器上做试验，MS Sqlserver 2000 数据库对于100万记录的简单数据表执行上述语句，时间在1分钟以上。如果在表的某个字段上做聚簇索引，第一次执行该语句的时间和没有索引的时间差不多，之后执行上述语句，速度很快，在1秒中以内，但当表的记录数发生较大变化后，再执行该语句又会经历一次耗时的过程。而且不是每个表都适合做聚簇索引的，对于数量巨大的表，如果需要经常增删操作，建聚簇索引是一个很不明智的做法，将会极大的影响增删的速度。那么有没有一个比较简单的方法快速获取表的记录总数呢？答案是有的。<br /> 在MS SQL 数据库中每个表都在sysindexes 系统表中拥有至少一条记录，该记录中的rows 字段会定时记录表的记录总数。下面是sysindexes 表的相关记录的含义： 
<p>列名      数据类型             描述<br />id            int                        表ID(如果 indid = 0 或255)。否则为索引所属表的ID<br />Indid       smallint                索引ID：<br />                                         0＝表<br />                                         1＝聚簇索引<br />                                         &gt;1＝非聚簇索引<br />                                        255＝具有text或image数据的表条目。<br />rows       int                       基于indid=0 和 indid=1地数据级行数，该值对于indid&gt;1重 复。如果indid=255，rows设置为0。<br />  <br />  <br />当表没有聚簇索引时，Indid = 0 否则为 1。</p><p>那么现在大家应该知道如何获取表的记录总数了，只需执行如下语句：<br />select rows from sysindexes where id = object_id(tablename) and indid in (0,1) </p><p>该方法获取表的记录总数的速度非常快，在毫秒级就可以完成，相比select count(*) 要快上数万倍，但是大家在运用该方法是一定要主要，该方法得到的表的总记录数不是一个精确值，原因是MS SQL 并不是实时更新该字段的值，而是定时更新，当从实践来看该值和精确值一般误差不大，如果你希望快速的粗略估算表的大小，建议你采用该方法。如果你希望得到精确值，那么请在执行上述语句前执行DBCC UPDATEUSAGE(DatabaseName,[TABLENAME]) WITH ROW_COUNTS 强制更新该字段的值，但这样第一次更新时会耗费大量的时间，这样做的效果和建有聚簇索引的表 select count (*) 效果相差不大，所以如果你希望相对快速地得到精确的表的记录总数，那么你有两种选择，建聚簇索引或者先DBCC 再使用上述方法。</p><img src ="http://www.blogjava.net/renyangok/aggbug/84745.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-12-01 09:57 <a href="http://www.blogjava.net/renyangok/archive/2006/12/01/84745.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关系数据库中的“键” </title><link>http://www.blogjava.net/renyangok/archive/2006/12/01/84742.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Fri, 01 Dec 2006 01:53:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/12/01/84742.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/84742.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/12/01/84742.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/84742.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/84742.html</trackback:ping><description><![CDATA[
		<p>（转自：<a href="http://www.cnblogs.com/pingkeke/archive/2006/05/29/412106.html">http://www.cnblogs.com/pingkeke/archive/2006/05/29/412106.html</a>）<br />主键和外键是把多个表组织为一个有效的关系数据库的粘合剂。主键和外键的设计对物理数据库的性能和可用性都有着决定性的影响。</p>
		<p>必须将数据库模式从理论上的逻辑设计转换为实际的物理设计。而主键和外键的结构是这个设计过程的症结所在。一旦将所设计的数据库用于了生产环境，就很难对这些键进行修改，所以在开发阶段就设计好主键和外键就是非常必要和值得的。</p>
		<p>首先来谈：主键。</p>
		<p>关系数据库依赖于主键---它是数据库物理模式的基石。主键在物理层面上只有两个用途：<br />1. 惟一地标识一行。</p>
		<p>2. 作为一个可以被外键有效引用的对象。</p>
		<p>基于以上这两个用途，下面给出了我在设计物理层面的主键时所遵循的一些原则：</p>
		<p>        1. 主键应当是对用户没有意义的。如果用户看到了一个表示多对多关系的连接表中的数据，并抱怨它没有什么用处，那就证明它的主键设计地很好。</p>
		<p>        2. 主键应该是单列的，以便提高连接和筛选操作的效率。</p>
		<p>             注：使用复合键的人通常有两个理由为自己开脱，而这两个理由都是错误的。其一是主键应当具有实际意义，然而，让主键具有意义只不过是给人为地破坏数据库提供了方便。其二是利用这种方法可以在描述多对多关系的连接表中使用两个外部键来作为主键，我也反对这种做法，理由是：复合主键常常导致不良的外键，即当连接表成为另一个从表的主表，而依据上面的第二种方法成为这个表主键的一部分，然，这个表又有可能再成为其它从表的主表，其主键又有可能成了其它从表主键的一部分，如此传递下去，越靠后的从表，其主键将会包含越多的列了。</p>
		<p>        3. 永远也不要更新主键。实际上，因为主键除了惟一地标识一行之外，再没有其他的用途了，所以也就没有理由去对它更新。如果主键需要更新，则说明主键应对用户无意义的原则被违反了。</p>
		<p>                 注：这项原则对于那些经常需要在数据转换或多数据库合并时进行数据整理的数据并不适用。</p>
		<p>        4. 主键不应包含动态变化的数据，如时间戳、创建时间列、修改时间列等。</p>
		<p>        5. 主键应当有计算机自动生成。如果由人来对主键的创建进行干预，就会使它带有除了惟一标识一行以外的意义。一旦越过这个界限，就可能产生认为修改主键的动机，这样，这种系统用来链接记录行、管理记录行的关键手段就会落入不了解数据库设计的人的手中。<br /><br /></p>
		<h1>
				<a name="_uniqueidentifier">
				</a>uniqueidentifier</h1>
		<p>全局唯一标识符 (GUID)。</p>
		<h5>注释</h5>
		<p>
				<b>uniqueidentifier</b> 数据类型的列或局部变量可用两种方法初始化为一个值： 
</p>
		<ul type="disc">
				<li>使用 NEWID<b></b>函数。<br /><br /></li>
				<li>将字符串常量转换为如下形式（xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx，其中每个 x 是 0-9 或 a-f 范围内的一个十六进制的数字）。例如，6F9619FF-8B86-D011-B42D-00C04FC964FF 即为有效的 <b>uniqueidentifier </b>值。 </li>
		</ul>
		<p>比较运算符可与 <b>uniqueidentifier </b>值一起使用。然而，排列并非通过比较两个值的位模式来实现。允许对 <b>uniqueidentifier</b> 值执行的操作只有比较 (=, &lt;&gt;, &lt;, &gt;, &lt;=, &gt;=) 和检查 NULL（IS NULL 和 IS NOT NULL）。不允许使用其它算术运算符。所有的列约束及属性（IDENTITY 除外）均允许用于 <b>uniqueidentifier </b>数据类型。 </p>
<img src ="http://www.blogjava.net/renyangok/aggbug/84742.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-12-01 09:53 <a href="http://www.blogjava.net/renyangok/archive/2006/12/01/84742.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>mysql DB(学习笔记)</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82286.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:32:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82286.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82286.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82286.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82286.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82286.html</trackback:ping><description><![CDATA[
		<p>1、mysql数据库有两种驱动：<br />MySQL Connector/J Driver、MMMysql driver。<br /><br />2、导入导出数据库命令：（bin目录下）<br />导出：mysqldump -u root -p bokele   &gt;c:/mysql.sql   --default-character-set=gbk   <br />导入：C:\mysql\bin\&gt; mysql -u root -p &lt;C:\helloapp\schema\sampledb.sql  --default-character-set=gbk   <br />说明：C:\mysql\bin\表示进入mysql程序根目录<br />C:\helloapp\schema\sampledb.sql是要导入数据库的文件的位置<br />c:/mysql.sql是导出的sql文件<br />--default-character-set=gbk   指编码方式<br /><br />3、修改root口令：（bin目录下）<br />bin&gt;mysql -u root -p<br />mysql&gt;set password for root@localhost=password('123');<br />说明：将root的口令设置为123<br /><br />4、启动停止mysql客户程序（bin目录下）<br />1）mysql -u root -p<br />2）（输入密码）<br />3）create database SAMPLEDB<br />4）user SAMPLE<br />5）（各种sql操作）<br />6）exit（退出）<br /><br />5、启动和停止mysql服务（命令行下）<br />启动：net start mysql    停止：net stop mysql<br /><br />6、注册和删除mysql服务（bin目录下）<br />注册：mysqld-nt --install       删除：mysqld-nt --remove</p>
		<p>7、导入mysql数据库时出现：Data too long for column '***' at row *，<br />描述：mysql用UTF8字符集，备份文件（***.sql）是gbk格式的，运行C:\mysql\bin\&gt; mysql -u root -p &lt;C:\***.sql  --default-character-set=gbk后（gbk指备份文件的格式），出现上面问题。filename字段定义如下：`filename` varchar(255) binary NOT NULL default '',<br />分析：因为mysql用utf8编码，所以一个字节占24位（UTF8字符是可变长度，英文8位，中文24位，为满足全是中文情况，用24位表示），但mysql的varchar类型有最大长度，而255×24可能超过最大长度，所以报错。可见原备份文件建数据库时应该使用的不是UTF8，而应为一个字符占8位的latin1编码方式，找到问题答案。<br />解决：在建表文件顶端加入以下语句：<br />drop database if exists Web;//Web为要建的数据库<br />create database Web default charset=latin1 ;<br />use Web;<br />set   charset   latin1;<br /><br /><font face="Verdana" size="2">7. 配置字符集<br /><br /> 建库时配置字符集<br /><br />create database testxxx default charset=utf8 <br /><br />建表时配置字符集<br /><br />CREATE TABLE `t_agent` (<br />`ID` smallint(5) NOT NULL<br />) DEFAULT CHARSET=utf8 ;<br /><br />修改字符集<br /><br />Windows平台<br />windows下的mysql配置文件是my.ini,一般在c:\windows\my.ini或者c:\winnt\my.ini可以直接在这个文件里面加上 <br />default-character-set=gbk #或gb2312,big5,utf8<br />然后重新启动mysql <br />service mysql restart<br />或 <br />/etc/init.d/mysql restart<br />或用其他方法重新启动，就生效了。 <br /><br />[编辑]Unix平台<br />linux下的mysql配置文件是my.cnf，一般是/etc/my.cnf，如果找不到可以用find命令找一下： <br />find / -iname my.cnf<br />在这个文件里面加上 <br />default-character-set=gbk #或gb2312,big5,utf8<br />然后重新启动mysql <br /><br />8. 配置排序字符集<br /><br />myisamchk -r -q --set-character-set=charset<br /></font><br />9、本机或远程访问mysql时，mysql进行了权限控制，在mysql.user表中记录了访问主机IP和权限的关系<!--StartFragment --> 。<br />问题一：远程登陆mysql的话：  <br />回复一：先在Mysql本机登录后，修改mysql.user表，其中hose=%表示远程连接的用户名，如果没有host=%的记录，你可以把host=localhost的两个记录的其中一个改过来,但一定要加上密码。 <br /><!--StartFragment -->回复二： 假如Database:Test   <br />  创建用户:Jacky   密码:   pwd   <br />  进入Mysql   <br />  &gt;grant   insert,delete,update,select,drop,create   on   Test.*   to   Jacky@"%"   identified   by   "pwd";     <br />回复三：<!--StartFragment --> 用它试试：   <br />  mysql&gt;GRAND   ALL   ON   DTBASE.*   TO   joe@192.168.0.2   IDENTIFIED   BY   "PASSWORD"   <br />//joe是用户名 <br />问题二：本地登陆mysql的话：<br />max经验：我在本机用Mysql control center登陆mysql，但总是显示“ERROR 1130:Host 'taiji-renyang' is not allowed to connect to this MySQL server”，后来发现是因为mysql.user表中只有HostName为localhost的记录，而MySql control center的配置为HostName：192.168.8.99，虽然192.168.8.99就是我得IP，但服务器识别不出来，终于搞清了！！！<br /><br />10.登陆url目前只能为：jdbc:mysql://localhost:3306/test，因为目前mysql数据库中user表只存了localhost这一个连接，如果用localhost的IP就不行，因为表中没有存。</p>
		<p>11.<br />查看所有数据库语句为：show databases;<br />进入某个数据库：use ***;(*** stand for a database)<br />进入某数据库后查看此数据库中所有的表：show tables;</p>
		<p>12.通过mysql control center导入导出sql语句：<br />a. 确保Mysql CC连接<br />b. 选择相应的库.表 =〉右键 =〉工具 =〉显示创建语句 =〉选中想要的表(可选择所有的表) =〉执行 =&gt; tools=&gt;Show Create=&gt;选中想要的表(可选择所有的表)=&gt;Execuete</p>
		<p>或者在sql中,执行:SHOW CREATE TABLE table_name;</p>
		<p> </p>
<img src ="http://www.blogjava.net/renyangok/aggbug/82286.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:32 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82286.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Java连接各种数据库的实例</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82287.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:32:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82287.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82287.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82287.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82287.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82287.html</trackback:ping><description><![CDATA[
		<div>此文中的代码主要列出连接数据库的关键代码，其他访问数据库代码省略</div>
		<div>1、Oracle8/8i/9i数据库（thin模式） <br />Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); <br />String url="jdbc:oracle:thin:@localhost:1521:orcl"; <br />//orcl为数据库的SID <br />String user="test"; <br />String password="test"; <br />Connection conn= DriverManager.getConnection(url,user,password); </div>
		<div>2、DB2数据库 <br />Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance(); <br />String url="jdbc:db2://localhost:5000/sample"; <br />//sample为你的数据库名 <br />String user="admin"; <br />String password=""; <br />Connection conn= DriverManager.getConnection(url,user,password); </div>
		<div>3、Sql Server7.0/2000数据库 <br />Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance(); <br />String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb"; <br />//mydb为数据库 <br />String user="sa"; <br />String password=""; <br />Connection conn= DriverManager.getConnection(url,user,password); </div>
		<div>4、Sybase数据库 <br />Class.forName("com.sybase.jdbc.SybDriver").newInstance(); <br />String url =" jdbc:sybase:Tds:localhost:5007/myDB"; <br />//myDB为你的数据库名 <br />Properties sysProps = System.getProperties(); <br />SysProps.put("user","userid"); <br />SysProps.put("password","user_password"); <br />Connection conn= DriverManager.getConnection(url, SysProps); </div>
		<div>5、Informix数据库 <br />Class.forName("com.informix.jdbc.IfxDriver").newInstance(); <br />String url = <br />"jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver; <br />user=testuser;password=testpassword"; <br />//myDB为数据库名 <br />Connection conn= DriverManager.getConnection(url); </div>
		<div>6、MySQL数据库 <br />Class.forName("org.gjt.mm.mysql.Driver").newInstance(); //mm驱动<br />Class.forName("com.mysql.jdbc.Driver");//Connector/J 3.0驱动，两个驱动选其一<br />String url ="jdbc:mysql://localhost/myDB?user=soft&amp;password=soft1234&amp;useUnicode=true&amp;characterEncoding=8859_1" ;<br />//myDB为数据库名 <br />Connection conn= DriverManager.getConnection(url); <br /><br /><br />Connection con = DriverManager.getConnection("jdbc:mysql://host:port/database","user","password");</div>
		<div>7、PostgreSQL数据库 <br />Class.forName("org.postgresql.Driver").newInstance(); <br />String url ="jdbc:postgresql://localhost/myDB" <br />//myDB为数据库名 <br />String user="myuser"; <br />String password="mypassword"; <br />Connection conn= DriverManager.getConnection(url,user,password); </div>
<img src ="http://www.blogjava.net/renyangok/aggbug/82287.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:32 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82287.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>sql教程&amp;学习笔记（不断更新）</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82283.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:31:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82283.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82283.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82283.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82283.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82283.html</trackback:ping><description><![CDATA[学习笔记：<br />
判断在某段时间内<br />
一.select * from table where talbe.time between to_date('2006-1-15','yyyy-mm-dd') and to_date('2008-1-15','yyyy-mm-dd') order by talbe.time;<br />
<br />
select * from table where talbe.time between trunc(date(formDate) )and trunc(date(toDate) )order by talbe.time;<br />
<br />
二.查询匹配<br />
select * from table where lower(table.username) like&nbsp;'%任杨%';<br />
<br />
三.如何获得前N条记录<br />
<div class="postbody">
<p>1. ORACLE <br />
SELECT * FROM TABLE1 WHERE ROWNUM&lt;=N </p>
<p>2. INFORMIX <br />
SELECT FIRST N * FROM TABLE1 where 1=1 </p>
<p>3. DB2 <br />
SELECT * ROW_NUMBER() OVER(ORDER BY COL1 DESC) AS ROWNUM WHERE ROWNUM&lt;=N <br />
或者<br />
SELECT COLUMN FROM TABLE where 1=1 FETCH FIRST N ROWS ONLY </p>
<p>4. SQL SERVER <br />
SELECT TOP N * FROM TABLE1 where 1=1 <br />
or<br />
SET ROWCOUNT N SELECT * FROM TABLE1 where 1=1 SET ROWCOUNT N1</p>
<p>5. SYBASE <br />
SET ROWCOUNT N SELECT * FROM TABLE1 where 1=1 SET ROWCOUNT N1</p>
<p>6. MYSQL <br />
SELECT * FROM TABLE1 where 1=1 LIMIT N </p>
<p>7. FOXPRO <br />
SELECT * TOP N FROM TABLE ORDER BY COLUMN</p>
<p>8. ACCESS <br />
SELECT TOP N * FROM TABLE1 where 1=1</p>
</div>
四，exists与in的比较<br />
<span class="style6">
<pre>这个例子比较了两个语义类似的查询。第一个查询使用 EXISTS 而第二个查询使用 IN。注意两个查询返回相同的信息。<br />
<br />
USE pubs<br />
GO<br />
SELECT DISTINCT pub_name<br />
FROM publishers<br />
WHERE EXISTS<br />
(SELECT *<br />
FROM titles<br />
WHERE pub_id = publishers.pub_id<br />
AND type = 'business')<br />
GO<br />
<br />
-- Or, using the IN clause:<br />
<br />
USE pubs<br />
GO<br />
SELECT distinct pub_name<br />
FROM publishers<br />
WHERE pub_id IN<br />
(SELECT pub_id<br />
FROM titles<br />
WHERE type = 'business')<br />
GO<br />
<br />
关于in和exist两者性能的说明：<font color="#ff0000" size="4"><strong>IN适合于外表大而内表小的情况；EXISTS适合于外表小而内表大的情况。<br />
参考：http://www.cnblogs.com/zwl12549/archive/2007/04/19/720028.html<br />
</strong></font></pre>
</span>五，exists只会返回0或者1，所以子循环里返回什么都无所谓，只要语句不出错就可以。所以可用返回常数来使执行速度更快。<br />
eg：一张表，四个字段：<br />
class, student, grade, cause<br />
班级，学生姓名，分数，科目<br />
我想查出每个班级中一个分数最高的成绩，和它对应的学生姓名、科目（每个班有很多学生、不同科目）<br />
<br />
有人答曰：<br />
Select A.* From TableName A <br />
Where Not Exists (Select 1 From TableName Where class=A.class And grade&gt;A.grade)<br />
<br />
六，查询插入的问题：<br />
两个表如下，把old_user表的数据导入new_user并在admin字段添加&#8216;admin&#8217;<br />
old_user: id, name, password<br />
new_user: id, name, password, admin<br />
<br />
insert &nbsp; into &nbsp; new_user (id, name, password) select id, name, password, 'admin' from old_user;<br />
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />
SQL教程：<br />
<br />
SQL是Structured Quevy Language(结构化查询语言)的缩写。SQL是专为数据库而建立的操作命令集，是一种功能齐全的数据库语言。在使用它时，只需要发出&#8220;做什么&#8221;的命令，&#8220;怎么做&#8221;是不用使用者考虑的。SQL功能强大、简单易学、使用方便，已经成为了数据库操作的基础，并且现在几乎所有的数据库均支持SQL。
<p>##1 二、SQL数据库数据体系结构 <br />
SQL数据库的数据体系结构基本上是三级结构，但使用术语与传统关系模型术语不同。在SQL中，关系模式(模式)称为&#8220;基本表&#8221;(base table)；存储模式(内模式)称为&#8220;存 储文件&#8221;(stored file)；子模式(外模式)称为&#8220;视图&#8221;(view)；元组称为&#8220;行&#8221;(row) <br />
；属性称为&#8220;列&#8221;(column)。名称对称如^00100009a^： </p>
<p>##1 三、SQL语言的组成 <br />
在正式学习SQL语言之前，首先让我们对SQL语言有一个基本认识，介绍一下SQL语言的 组成： <br />
1.一个SQL数据库是表(Table)的集合，它由一个或多个SQL模式定义。 <br />
2.一个SQL表由行集构成，一行是列的序列(集合)，每列与行对应一个数据项。 <br />
3.一个表或者是一个基本表或者是一个视图。基本表是实际存储在数据库的表，而视图是由若干基本表或其他视图构成的表的定义。 <br />
4.一个基本表可以跨一个或多个存储文件，一个存储文件也可存放一个或多个基本表。每个存储文件与外部存储上一个物理文件对应。 <br />
5.用户可以用SQL语句对视图和基本表进行查询等操作。在用户角度来看，视图和基本表是一样的，没有区别，都是关系(表格)。 <br />
6.SQL用户可以是应用程序，也可以是终端用户。SQL语句可嵌入在宿主语言的程序中使用，宿主语言有FORTRAN，COBOL，PASCAL，PL/I，C和Ada语言等。SQL用户也能作为独立的用户接口，供交互环境下的终端用户使用。 </p>
<p>##1 四、对数据库进行操作 <br />
SQL包括了所有对数据库的操作，主要是由4个部分组成： <br />
1.数据定义：这一部分又称为&#8220;SQL DDL&#8221;，定义数据库的逻辑结构，包括定义数据库、基本表、视图和索引4部分。 <br />
2.数据操纵：这一部分又称为&#8220;SQL DML&#8221;，其中包括数据查询和数据更新两大类操作，其中数据更新又包括插入、删除和更新三种操作。 <br />
3.数据控制：对用户访问数据的控制有基本表和视图的授权、完整性规则的描述，事务控制语句等。 <br />
4.嵌入式SQL语言的使用规定：规定SQL语句在宿主语言的程序中使用的规则。<br />
&nbsp;</p>
<p>##2 (一)数据定义 <br />
SQL数据定义功能包括定义数据库、基本表、索引和视图。首先，让我们了解一下SQL所提供的基本数据类型：(如^00100009b^) <br />
1.数据库的建立与删除 <br />
(1)建立数据库：数据库是一个包括了多个基本表的数据集，其语句格式为：CREATE DATABASE &lt;数据库名&gt; ［其它参数］ <br />
其中，&lt;数据库名&gt;在系统中必须是唯一的，不能重复，不然将导致数据存取失误。［其它参数］因具体数据库实现系统不同而异。 <br />
例：要建立项目管理数据库(xmmanage)，其语句应为：CREATE DATABASE xmmanage </p>
<p>(2) 数据库的删除：将数据库及其全部内容从系统中删除。其语句格式为：DROP DATABASE &lt;数据库名&gt; <br />
例：删除项目管理数据库(xmmanage)，其语句应为： DROP DATABASE xmmanage </p>
<p>2.基本表的定义及变更 <br />
本身独立存在的表称为基本表，在SQL语言中一个关系唯一对应一个基本表。基本表的定义指建立基本关系模式，而变更则是指对数据库中已存在的基本表进行删除与修改。 <br />
(1)基本表的定义：基本表是非导出关系，其定义涉及表名、列名及数据类型等，其语 <br />
句格式为：CREATE TABLE［&lt;数据库名&gt;.］&lt;表名&gt; <br />
(&lt;列名&gt; 数据类型 ［缺省值］ ［NOT NULL / NULL］ <br />
［，&lt;列名&gt; 数据类型 ［缺省值］ ［NOT NULL / NULL］］...... <br />
［，UNIQUE (列名［，列名］......)］ <br />
［，PRIMARY KEY(列名)］ <br />
［，FOREIGN KEY(列名［，列名］......)REFERENCE &lt;表名&gt;(列名［，列名］ <br />
......)］ <br />
［，CHECK(条件)］ ［其它参数］) 其中，〈数据库名〉.］指出将新建立的表存放于该数据库中； <br />
新建的表由两部分组成：其一为表和一组列名，其二是实际存放的数据(即可在定义表的同时，直接存放数据到表中)；列名为用户自定义的易于理解的名称，列名中不能使用空格；数据类型为上面所介绍的几种标准数据类型；<br />
［NOT NULL/NULL］指出该列是否允许存放空值，SQL语言支持空值的概念，所谓空值是&#8220;不知道&#8221;或&#8220;无意义&#8221;的值，值得注意的是数据&#8220;0&#8221;和空格都不是空值，系统一般默认允许为空值，所以当不允许为空值时，必须明确使用NOT NULL； <br />
［，UNIQUE］将列按照其规定的顺序进行排列，如不指定排列顺序，则按列的定义顺序排列； <br />
［PRIMARY KEY］用于指定表的主键(即关系中的主属性)，实体完整性约束条件规定：主键必须是唯一的，非空的； <br />
［， FOREIGN KEY (列名［，列名］......) REFERENCE&lt;表名&gt;(列名［，列名］ ......)］是用于指定外键参照完整性约束条件，FOREIGN KEY指定相关列为外键，其参照对象为另外一个表的指定列，即使用REFERENCE引入的外表中的列，当不指定外表列名时，系统将默认其列名与参照键的列名相同，要注意的是：使用外键时必须使用参照，另外数据的外键参照完整性约束条件规定：外键的值要么与相对应的主键相同，要么为空值(具体由实现系统不同而异)［，CHECK］用于使用指定条件对存入表中的数据进行检查，以确定其合法性，提高数据的安全性。 </p>
<p>例：要建立一个学生情况表(student) <br />
CREATE TABLE student file://创建基本表student <br />
(st_class CHAR(8)，// 定义列st_class班级，数据类型为8位定长字符串 <br />
st_no CHAR(10) NOT NULL，//定义列st_no学号，类型为10位定长字符串，非空 <br />
st_name CHAR(8) NOT NULL，//定义列st_name姓名，类型为8位定长字符串，非空 <br />
st_sex CHAR(2)，//定义列st_sex性别，类型为2位定长字符串 <br />
st_age SMALLINT，//定义列st_age年龄，类型为短整型 <br />
PRIMARY KEY (st_no))//定义st_no学号为主键。 </p>
<p>例：要建立课程设置表(subject) <br />
CREATE TABLE subject//创建基本表subject <br />
(su_no CHAR(4) NOT NULL，// 定义列su_no课号，类型为4位定长字符串，非空 <br />
su_subject CHAR(20) NOT NULL，// 定义列su_subject课程名，类型为20位定长字符 串，非空 <br />
su_credit INTEGER，// 定义列su_credit学分，类型为长整数 <br />
su_period INTEGER，//定义列su_period学时，类型为长整数 <br />
su_preno CHAR(4)，//定义列su_preno先修课号，类型为4位定长字符串 <br />
PRIMARY KEY(su_no))//定义su_no课号为主键。 </p>
<p>例：要建立学生选课表(score) <br />
CREATE TABLE score file://创建基本表score <br />
(st_no CHAR(10)，//定义列st_no学号，类型为10位定长字符串 <br />
su_no CHAR(4)，//定义列su_no课号，类型为4位定长字符串 <br />
sc_score INTEGER NULL，//定义列sc_score，类型为长整形，可以为空值 <br />
FOREIGN KEY (st_no) REFERENCE student，//从表student中引入参照外键st_no，以 <br />
确保本表与表student的关联与同步 <br />
FOREIGN KEY (suno) REFERENCE subject)//从表subject中引入参照外键su_no，以确 <br />
保本表与表subject的关联与同步 </p>
<p>(2)基本表的删除：用以从数据库中删除一个基本表及其全部内容，其语句格式为： <br />
DROP TABLE［&lt;数据库名&gt;.］表名 <br />
例如：将上面建立的表都删除 <br />
DROP TABLE student，subject，score </p>
<p>(3)基本表的修改：在基本表建立并使用一段时间后，可能需要根据实际要求对基本表 <br />
的结构进行修改，即增加新的属性或删除属性。 <br />
增加属性的语句格式为： <br />
ALTER TABLE ［&lt;数据库名&gt;.］表名 ADD <br />
(&lt;列名&gt; 数据类型 ［缺省值］ ［NOT NULL / NULL］ <br />
［，&lt;列名&gt; 数据类型［缺省值］［NOT NULL / NULL］］...... <br />
［，UNIQUE (列名［，列名］......)］ <br />
［，PRIMARY KEY(列名)］ <br />
［，FOREIGN KEY(列名［，列名］......) REFERENCE &lt;表名&gt;(列名［，列名］ ......)］ <br />
［，CHECK(条件)］［其它参数］) </p>
<p>例如：在基本表student中加入列stborn出生日期，数据类型为DATE，且不能为空值ALTER TABLE student ADD (stborn DATE NOT NULL) 删除属性的语句格式为： <br />
ALTER TABLE ［&lt;数据库名&gt;.］表名 DROP <br />
( &lt;列名&gt; 数据类型 ［缺省值］［NOT NULL / NULL］ <br />
［，&lt;列名&gt; 数据类型 ［缺省值］［NOT NULL / NULL］］......) <br />
例如：将基本表student中的列st_age删除 ALTER TABLE student DROP (st_age) </p>
<p>3.视图定义与删除 <br />
在SQL 中，视图是外模式一级数据结构的基本单位。它是从一个或几个基本表中导出的表，是从现有基本表中抽取若干子集组成用户的&#8220;专用表&#8221;。这种构造方式必须使用 SQL中的SELECT语句来实现。在定义一个视图时，只是把其定义存放在系统的数据中，而并不直接存储视图对应的数据，直到用户使用视图时才去求得对应的数据。 </p>
<p>(1)视图的定义：定义视图可以使用CREATE VIEW语句实现，其语句格式为： <br />
CREATE VIEW 视图名 AS SELECT语句 </p>
<p>从一个基本表中导出视图： <br />
例：从基本表student中导出只包括女学生情况的视图 <br />
CREATE VIEW WOMANVIEW AS file://创建一个视图WOMANVIEW <br />
SELECT st_class，st_no，st_name，st_age file://选择列st_class，st_no，st_name， <br />
st_age显示 <br />
FROM student file://从基本表student引入 <br />
WHERE st_sex=&#8216;女&#8217;//引入条件为性别为&#8220;女&#8221;，注意字符变量都使用单引号引用 </p>
<p>从多个基本表中导出视图： <br />
例如：从基本表student和score中导出只包括女学生且分数在60分以上的视图 <br />
CREATEVIEW WOMAN_SCORE AS file://定义视图WOMANSCORE <br />
SELECT student.st_class，student.st_no，student.st_name，student.st_age， <br />
score.sc_score file://有选择性显示相关列 <br />
FROM student.score file://从基本表student和score中引入 <br />
WHERE student.st_sex=&#8216;女&#8217;AND score.sc_score&gt;=60 AND <br />
student.st_no=score.st_no file://选择条件：性别为&#8220;女&#8221; 且分数在60分以上。并使用 <br />
st_no将两表联系起来。以后如果进行这一视图的应用，则只需使用语句 <br />
SELECT * FROM WOMAN_SCORE file://其中&#8220;*&#8221;为通配符，代表所有元素 <br />
(2)视图的删除：用于删除已不再使用的视图，其语句格式如下： <br />
DROP VIEW 视图名 <br />
例：将上面建立的WOMAN_SCORE视图删除 <br />
DROP VIEW WOMAN_SCORE </p>
<p>4.索引的定义与删除 <br />
索引属于物理存储概念，而不是逻辑的概念。在SQL中抛弃了索引概念，直接使用主键概念。值得一提的是，有些关系DBMS同时包括索引机制和主键机制，这里我们推荐使用主键机制，因为它对系统资源占用较低且效率较高。 </p>
<p>(1)索引的定义：索引是建立在基本表之上的，其语句格式为： <br />
CREATE ［UNIQUE］ INDEX 索引名 ON <br />
［&lt;数据库名&gt;.］表名(列名 ［ASC/DESC］［，列名 ［ASC/DESC］］......) <br />
这里，保留字UNIQUE表示基本表中的索引值不允许重复，若缺省则表示索引值在表中允许重复；DESC表示按索引键降序排列，若缺省或ASC表示升序排列。<br />
例：对基本表student中的st_no和st_age建立索引，分别为升序与降序，且索引值不允许重复 <br />
CREATE UNIQUE INDEX STINDEX ON//创建索引STINDEX <br />
student(st_no ASC，st_age DESC)//对student中的st_no和st_age建立索引 </p>
<p>(2)索引的删除： <br />
DROP INDEX 索引名 <br />
例：删除上面建立的索引STINDEX <br />
DROP INDEX STINDEX <br />
<br />
</p>
<p>##2 (二)数据查询 <br />
SQL是一种查询功能很强的语言，只要是数据库存在的数据，总能通过适当的方法将它从数据库中查找出来。SQL中的查询语句只有一个：SELECT，它可与其它语句配合完成所有的查询功能。SELECT语句的完整语法，可以有6个子句。完整的语法如下： </p>
<p>SELECT 目标表的列名或列表达式集合 <br />
FROM 基本表或(和)视图集合 <br />
［WHERE条件表达式］ <br />
［GROUP BY列名集合 <br />
［HAVING组条件表达式］］ <br />
［ORDER BY列名［集合］&#8230;］ <br />
整个语句的语义如下：从FROM子句中列出的表中，选择满足WHERE子句中给出的条件表达式的元组，然后按GROUPBY子句(分组子句)中指定列的值分组，再提取满足HAVING子句中组条件表达式的那些组，按SELECT子句给出的列名或列表达式求值输出。ORDER子句(排序子句)是对输出的目标表进行重新排序，并可附加说明 ASC(升序)或DESC(降序) <br />
排列。在WHERE子句中的条件表达式F中可出现下列操作符和运算函数： <br />
算术比较运算符：&lt;，&lt;=，&gt;，&gt;=，=，&lt;&gt;。 <br />
逻辑运算符：AND，OR，NOT。 <br />
集合运算符：UNION(并)，INTERSECT(交)，EXCEPT(差)。 <br />
集合成员资格运算符：IN，NOT IN <br />
谓词：EXISTS(存在量词)，ALL，SOME，UNIQUE。 <br />
聚合函数：AVG(平均值)，MIN(最小值)，MAX(最大值)，SUM(和)，COUNT(计数)。 <br />
F中运算对象还可以是另一个SELECT语句，即SELECT语句可以嵌套。 <br />
上面只是列出了WHERE子句中可出现的几种主要操作，由于WHERE子句中的条件表达式可以很复杂，因此SELECT句型能表达的语义远比其数学原形要复杂得多。 <br />
下面，我们以上面所建立的三个基本表为例，演示一下SELECT的应用： <br />
1.无条件查询 <br />
例：找出所有学生的的选课情况 <br />
SELECT st_no，su_no <br />
FROM score <br />
例：找出所有学生的情况 <br />
SELECT* <br />
FROM student <br />
&#8220;*&#8221;为通配符，表示查找FROM中所指出关系的所有属性的值。 </p>
<p>2.条件查询 <br />
条件查询即带有WHERE子句的查询，所要查询的对象必须满足WHERE子句给出的条件。 <br />
例：找出任何一门课成绩在70以上的学生情况、课号及分数 <br />
SELECT UNIQUE student.st_class，student.st_no，student.st_name， <br />
student.st_sex，student.st_age，score.su_no，score.score <br />
FROM student，score <br />
WHERE score.score&gt;=70 AND score.stno=student.st_no <br />
这里使用UNIQUE是不从查询结果集中去掉重复行，如果使用DISTINCT则会去掉重复行。 <br />
另外逻辑运算符的优先顺序为NOT&#8594;AND&#8594;OR。 <br />
例：找出课程号为c02的，考试成绩不及格的学生 <br />
SELECT st_no <br />
FROM score <br />
WHERE su_no=&#8216;c02&#8217;AND score&lt;60 </p>
<p>3.排序查询 <br />
排序查询是指将查询结果按指定属性的升序(ASC)或降序(DESC)排列，由ORDER BY子句指明。 <br />
例：查找不及格的课程，并将结果按课程号从大到小排列 <br />
SELECT UNIQUE su_no <br />
FROM score <br />
WHERE score&lt;60 <br />
ORDER BY su_no DESC </p>
<p>4.嵌套查询 <br />
嵌套查询是指WHERE子句中又包含SELECT子句，它用于较复杂的跨多个基本表查询的情 况。 <br />
例：查找课程编号为c03且课程成绩在80分以上的学生的学号、姓名 <br />
SELECT st_no，st_name <br />
FROM student <br />
WHERE stno IN (SELECT st_no <br />
FROM score <br />
WHERE su_no=&#8216;c03&#8217; AND score&gt;80 ) <br />
这里需要明确的是：当查询涉及多个基本表时用嵌套查询逐次求解层次分明，具有结构程序设计特点。在嵌套查询中，IN是常用到的谓词。若用户能确切知道内层查询返回的是单值，那么也可用算术比较运算符表示用户的要求。 </p>
<p>5.计算查询 <br />
计算查询是指通过系统提供的特定函数(聚合函数)在语句中的直接使用而获得某些只有经过计算才能得到的结果。常用的函数有： <br />
COUNT(*) 计算元组的个数 <br />
COUNT(列名) 对某一列中的值计算个数 <br />
SUM(列名) 求某一列值的总和(此列值是数值型) <br />
AVG(列名) 求某一列值的平均值(此列值是数值型) <br />
MAX(列名) 求某一列值中的最大值 <br />
MIN(列名) 求某一列值中的最小值 <br />
例：求男学生的总人数和平均年龄 <br />
SELECT COUNT(*)，AVG(st_age) <br />
FROM student <br />
WHERE st_sex=&#8216;男&#8217; <br />
例：统计选修了课程的学生的人数 <br />
SELECT COUNT(DISTINCT st_no) <br />
FROM score <br />
注意：这里一定要加入DISTINCT，因为有的学生可能选修了多门课程，但统计时只能按1人统计，所以要使用DISTINCT进行过滤。 <br />
<br />
</p>
<p>##2 (三) 数据更新 <br />
数据更新包括数据插入、删除和修改操作。它们分别由INSERT语句，DELETE语句及UPDATE语句完成。这些操作都可在任何基本表上进行，但在视图上有所限制。其中，当视图是由单个基本表导出时，可进行插入和修改操作，但不能进行删除操作；当视图是从多个基本表中导出时，上述三种操作都不能进行。 </p>
<p>1.数据插入 <br />
将数据插入SQL的基本表有两种方式：一种是单元组的插入，另一种是多元组的插入。 <br />
单元组的插入：向基本表score中插入一个成绩元组(100002，c02，95)，可使用以下语句： <br />
INSERT INTO score(st_no，su_no，score) VALUES(&#8216;100002&#8217;，&#8216;c02&#8217;，95) <br />
由此，可以给出单元组的插入语句格式： <br />
INSERT INTO表名(列名1［，列名2］&#8230;) VALUES(列值1［，列值2］&#8230;) 其中，列名序列为要插入值的列名集合，列值序列为要插入的对应值。若插入的是一个表的全部列值，则列名可以省略不写如上面的(st_no，su_no，score)可以省去；若插 <br />
入的是表的部分列值，则必须列出相应列名，此时，该关系中未列出的列名取空值。 <br />
多元组的插入：这是一种把SELECT语句查询结果插入到某个已知的基本表中的方法。<br />
例如：需要在表score中求出每个学生的平均成绩，并保留在某个表中。此时可以先创建一个新的基本表stu_avggrade，再用INSERT语句把表score中求得的每一个学生的平均成绩(用SELECT求得)插入至stu_avggrade中。 <br />
CREATE TABLE stu_avggrade <br />
(st_no CHAR(10) NOT NULL，//定义列st_no学号，类型为10位定长字符串，非空 <br />
age_grade SMALLINT NOT NULL )// 定义列age_grade平均分，类型为短整形，非空 <br />
INSERT INTO stu_avggrade(st_no，age_grade) <br />
SELECT st_no，AVG(score) <br />
FROM score <br />
GROUP BY st_no file://因为要求每一个学生所有课程的平均成绩，必须按学号分组进行计算。 </p>
<p>2.数据删除 <br />
SQL的删除操作是指从基本表中删除满足WHERE&lt;条件表达式&gt;的记录。如果没有WHERE子 <br />
句，则删除表中全部记录，但表结构依然存在。其语句格式为： <br />
DELETE FROM表名［WHERE 条件表达式］ <br />
下面举例说明： <br />
单元组的删除：把学号为100002的学生从表student中删除，可用以下语句： <br />
DELETE FROM student <br />
WHERE st_no=&#8216;100002&#8217;//因为学号为100002的学生在表student中只有一个，所以为单元组的删除<br />
多元组的删除：学号为100002的成绩从表score中删除，可用以下语句： <br />
DELETE FROM score <br />
WHERE st_no=&#8216;100002&#8217;//由于学号为100002的元组在表score中可能有多个，所以为多元组删除<br />
带有子查询的删除操作：删除所有不及格的学生记录，可用以下语句 <br />
DELETE FROM student <br />
WHERE st_no IN <br />
(SELETE st_no <br />
FROM score <br />
WHERE score&lt;60) </p>
<p>3.数据修改 <br />
修改语句是按SET子句中的表达式，在指定表中修改满足条件表达式的记录的相应列值。其语句格式如下： <br />
UPDATE 表名 SET 列名=列改变值［WHERE 条件表达式］ <br />
例：把c02的课程名改为英语，可以用下列语句： <br />
UPDATE subject <br />
SET su_subject=&#8216;英语&#8217; <br />
WHERE su_no=&#8216;c02&#8217; <br />
例：将课程成绩达到70分的学生成绩，再提高10% <br />
UPDATE score <br />
SET score=1.1*score <br />
WHERE score&gt;=70 <br />
SQL的删除语句和修改语句中的WHERE子句用法与SELECT中WHERE子句用法相同。数据的删除和修改操作，实际上要先做SELECT查询操作，然后再把找到的元组删除或修改。 <br />
</p>
<p>##2 (四) 数据控制 <br />
由于数据库管理系统是一个多用户系统，为了控制用户对数据的存取权利，保持数据的 共享及完全性，SQL语言提供了一系列的数据控制功能。其中，主要包括安全性控制、完整性控制、事务控制和并发控制。 </p>
<p>1.安全性控制 <br />
数据的安全性是指保护数据库，以防非法使用造成数据泄露和破坏。保证数据安全性的主要方法是通过对数据库存取权力的控制来防止非法使用数据库中的数据。即限定不同用户操作不同的数据对象的权限。存取权控制包括权力的授与、检查和撤消。权力授与和撤消命令由数据库管理员或特定应用人员使用。系统在对数据库操作前，先核实相应用户是否有权在相应数据上进行所 <br />
要求的操作。 <br />
(1)权力授与：权力授与有数据库管理员专用的授权和用户可用的授权两种形式。数据库管理员专用授权命令格式如下： <br />
|CONNECT | GRANT|RESOURCE|TO 用户名［IDENTIFED BY 口令］|DBA | 其中，CONNECT表示数据库管理员允许指定的用户具有连接到数据库的权力，这种授权是针对新用户；RESOURCE表示允许用户建立自己的新关系模式，用户获得CONNECT权力后，必须获得RESOURCE权力才能创建自己的新表；DBA表示数据库管理员将自己的特权授与指定的用户。若要同时授与某用户上述三种授权中的多种权力，则必须通过三个相应的GRANT命令指定。 <br />
另外，具有CONNECT和RESOURCE授权的用户可以建立自己的表，并在自己建立的表和视图上具有查询、插入、修改和删除的权力。但通常不能使用其他用户的关系，除非能获得其他用户转授给他的相应权力。 <br />
例：若允许用户SSE连接到数据库并可以建立他自己的关系，则可通过如下命令授与权力： <br />
GRANT CONNECT TO SSE INENTIFIED BY BD1928 <br />
GRANT RESOURCE TO SSE <br />
用户可用的授权是指用户将自己拥有的部分或全部权力转授给其他用户的命令形式，其命令格式如下： <br />
|SELECT | <br />
|INSERT | <br />
|DELETE | <br />
GRANT|UPDATE(列名1[，列名2]&#8230;)|ON|表名 |TO|用户名|［WITH GRANT OPTION］ <br />
|ALTER | |视图名| |PUBLIC| <br />
|NDEX | <br />
|ALL | <br />
若对某一用户同时授与多种操作权力，则操作命令符号可用&#8220;，&#8221;相隔。PUBLIC 表示将权力授与数据库的所有用户，使用时要注意： <br />
任选项WITH GRANT OPTION表示接到授权的用户，具有将其所得到的同时权力再转授给其他用户权力。 <br />
例：如果将表student的查询权授与所有用户，可使用以下命令： <br />
GRANT SELECT ON student TO PUBLIC <br />
例：若将表subject的插入及修改权力授与用户SSE并使得他具有将这种权力转授他人的 <br />
权力，则可使用以下命令： <br />
GRANT INSERT，UPDATE(su_subject) ON subject TO SSE WITH GRANT OPTION 这里，UPDATE后面跟su_subject是指出其所能修改的列。 <br />
(2)权力回收：权力回收是指回收指定用户原已授与的某些权力。与权力授与命令相匹配，权力回收也有数据库管理员专用和用户可用的两种形式。 <br />
DBA专用的权力回收命令格式为： <br />
|CONNECT | <br />
REVOKE|RESOURCE|FROM用户名 <br />
|DBA | <br />
用户可用的权力回收命令格式为： <br />
|SELECT | <br />
|INSERT | <br />
|DELETE | <br />
REVOKE|UPDATE(列名1［，列名2］&#8230;) |ON|表名 |FROM |用户名| <br />
|ALTER | |视图名| |PUBLIC| <br />
|INDEX | <br />
|ALL | <br />
例：回收用户SSE的DBA权力： <br />
REVOKE DBA FROM SSE </p>
<p>2.完整性控制 <br />
数据库的完整性是指数据的正确性和相容性，这是数据库理论中的重要概念。完整性控制的主要目的是防止语义上不正确的数据进入数据库。关系系统中的完整性约束条件包括实体完整性、参照完整性和用户定义完整性。而完整性约束条件的定义主要是通过CREATE TABLE语句中的［CHECK］子句来完成。另外，还有一些辅助命令可以进行数据完整性保护。如UNIQUE和NOT NULL，前者用于防止重复值进入数据库，后者用于防止空值。 </p>
<p>3.事务控制 <br />
事务是并发控制的基本单位，也是恢复的基本单位。在SQL中支持事务的概念。所谓事务，是用户定义的一个操作序列(集合)，这些操作要么都做，要么一个都不做，是一个不可分割的整体。一个事务通常以 BEGIN TRANSACTION开始，以COMMIT或ROLLBACK结束。 <br />
SQL提供了事务提交和事务撤消两种命令： <br />
(1)事务提交：事务提交的命令为： <br />
COMMIT ［WORK］ <br />
事务提交标志着对数据库的某种应用操作成功地完成，所有对数据库的操作都必须作为事务提交给系统时才有效。事务一经提交就不能撤消。 <br />
(2)事务撤消：事务撤消的命令是： <br />
ROLLBACK ［WORK］ <br />
事务撤消标志着相应事务对数据库操作失败，因而要撤消对数据库的改变，即要&#8220;回 滚&#8221;到相应事务开始时的状态。当系统非正常结束时(如掉电、系统死机)，将自动执行ROLLBACK命令SQL还提供了自动提交事务的机制，其命令为： <br />
SET AUTO COMMIT ON <br />
其对应的人工工作方式命令为： <br />
SET AUTO COMMIT OFF <br />
一旦规定了自动提交事务方式，则系统将每条SQL命令视为一个事务，并在命令成功执行完成时自动地完成事务提交。 </p>
<p>4.并发控制 <br />
数据库作为共享资源，允许多个用户程序并行地存取数据。当多个用户并行地操作数据库时，需要通过并发控制对它们加以协调、控制，以保证并发操作的正确执行，并保证数据库的一致性。在SQL中，并发控制采用封锁技术实现，当一个事务欲对某个数据对象操作时，可申请对该对象加锁，取得对数据对象的一定控制，以限制其他事务对该对象的操作。其语句格式为： <br />
|SHARE | <br />
LOCK TABLE 表名(或表名集合)IN |EXCLUSVE |MODE ［NOWAIT] <br />
|SHARE UPDATE| <br />
其中，表名(或表名集合)中指出封锁对象，若为多个表名，则各个表名间以&#8220;，&#8221;相隔 ；任选项NOWAIT表示多个用户要求封锁相同的关系时，后来提出的要求会被立即退回去，否则会等待该资源释放。 <br />
SHARE 表示共享封锁方式；EXCLUSIVE表示独占封锁方式；SHARE UPDAE表示共享更新封锁方式。其中共享封锁方式允许其他事务读同一数据，但防止其他事务对已封锁的表进行更新，该锁主要防止在表的两次查询之间对该表的改动；共享更新封锁SHARE UPDATE 是一个行封锁机制，它可改善表级封锁的并行性，它能允许并发事务读和修改一个表中的不同的行；独占封锁方式EXCLUSIVE禁止其他事务获得一个共享锁且禁止其他事务执行任何数据操作语句，即一旦某个运行事务对某个数据对象施加了排它锁，则其他任何事务都不能再对该数据对象施加任何方式的锁，只有处于等待状态。如果不想无限等待，则选择NOWAIT。 <br />
PHP(Hypertext Preprocessor，超文本预处理器)是一个递归的缩写名称，它是一种内嵌在HTML页面内的脚本语言。它的功能强大，使用方便，开发难度不大，而且可以免费使用。<br />
</p>
<p>sql 的基本语句<br />
表的建立 <br />
关系数据库的主要特点之一就是用表的方式组织数据。表是SQL语言存放数据、查找数据以及更新数据的基本数据结构。在SQL语言中，表有严格的定义，它是一种二维表，对于这种表有如下规定：<br />
1)每一张表都有一个名字，通常称为表名或关系名。表名必须以字母开头，最大长度为30个字符。<br />
2)一张表可以由若干列组成，列名唯一，列名也称作属性名。<br />
3)表中的一行称为一个元组，它相当于一条记录。<br />
4)同一列的数据必须具有相同的数据类型。<br />
5)表中的每一个列值必须是不可分割的基本数据项。<br />
注意：当用户需要新的数据结构或表存放数据时，首先要生成一个表。<br />
语法：<br />
CREATE TABLE 表名 [表约束]<br />
(列名1 数据类型 [缺省值1，列约束1]<br />
(列名2 数据类型 [缺省值2，列约束2]&#8230;<br />
列名n 数据类型 [缺省值n，列约束n]<br />
[TABLESPACE 表空间名称]<br />
[STORAGE (存贮的子句）]<br />
[ENABLE 约束名]<br />
[DISABLE 约束名]　 <br />
插入数据 　<br />
当一个表新建成时，它里面没有数据，通过向表中扦入数据，建成表的实例。<br />
语句句法：<br />
INSERT INTO 表名[(列名1,&#8230;)]<br />
VALUES(值1，值2，&#8230;,值n)<br />
[子查询]；<br />
假设有一张表Student如下所示：<br />
<br />
NO NAME AGE <br />
1001 A 12 <br />
1002 B 14 <br />
将新学生E增加到上表中，并按照表的结构将信息添加完整，需要如下语句：<br />
INSERT INTO STUDENT VALUSE(1003, 'E',12);　 <br />
修改数据 <br />
对表中已有数据进行修改，语句句法：<br />
UPDATE 表名SET 列名1＝表达式1，列名2＝表达式2，&#8230;<br />
WHERE 条件；<br />
例如：对下表Student<br />
<br />
NO NAME AGE <br />
1001 A 12 <br />
1002 B 14 <br />
将B的年纪改为18；应该执行以下语句：<br />
UPDATE STUDENT SET AGE=18 WHERE NAME='B';　 <br />
删除数据 <br />
删除表中已有数据，不能删除不存在的数据。<br />
语句句法: <br />
DELETE FROM 表名 WHERE 条件；<br />
例如：<br />
对下面Student表进行删除，要删除其中年纪为12的学生；<br />
<br />
NO NAME AGE <br />
1001 A 12 <br />
1002 B 14 <br />
DELETE FROM STUDENT WHERE AGE＝12；<br />
表结构的修改 <br />
在已存在的表中增加新列，语句句法：<br />
ALTER TABLE 表名 ADD(新列名 数据类型(长度))；<br />
??? 例如：<br />
??? ALTER TABLE STUDENT ADD (DEPARTMENT CHAR(8));<br />
b.增加已有列的数据类型。<br />
??? 例如：<br />
??? ALTER TABLE STUDENT MODIFY(NAME VARCHAR2(25));<br />
表的删除 <br />
将已经存在的表删除，语句句法:<br />
??? DROP TABLE表名；<br />
??? 例如：<br />
??? DROP TABLE EMP；　 <br />
查询语句 <br />
SELECT命令的语法为：<br />
SELECT [DISTINCT|ALL] {*|模式名.] {表名|视图名|<br />
快照名] .*&#8230;| {表达式[列别名]&#8230;} } [, [模式名. ] {表名|<br />
视图名|} .*&#8230;| 表达式[列别名] ]&#8230;<br />
FROM [模式名.] {表名|视图名|快照名} [@数据库链名] [表别名]<br />
[, [模式名.] {表名|视图名|快照名} [@数据库链名]<br />
[表别名] ]&#8230;<br />
[WHERE条件]<br />
[START WITH条件 CONNECT BY 条件]<br />
[GROUP BY表达式[，表达式] &#8230;[HAVING条件]<br />
[UNION|UNION ALL |INTERSECT|MINUS]SELECT命令<br />
[ORDER BY{表达式|位置} [ASC|DESC] [, {表达式|位置[ASC|DESC]}]&#8230;]<br />
例如：对于STUDENT表:<br />
<br />
NO NAME AGE <br />
1001 AE 12 <br />
1002 BT 14 <br />
(1) 查询年纪为12的学生姓名；<br />
SELECT STUDENT.NAME FROM STUDENT WHERE AGE=12;<br />
(2) 查询年纪在12至16岁之间的学生姓名；<br />
SELECT STUDENT.NAME FROM STUDENT WHERE AGE BETWEEN 12 AND 16;<br />
(3) 查询年纪不在12至16岁之间的学生姓名；<br />
SELECT STUDENT.NAME FROM STUDENT WHERE AGE NOT BETWEEN 12 AND 16;<br />
(4) 查询所有姓名以A开头的学生的姓名；<br />
SELECT STUDENT.NAME FROM STUDENT WHERE NAME LIKE 'A%';<br />
(5) 列出所有学生年纪的和，年纪的平均值，最大值，最小值，最大值与最小值之间的差值；<br />
SELECT AVG(AGE), SUM(AGE), MAX(AGE), MIN(AGE), MAX(AGE)-MIN(AGE);<br />
(6) 将所有学生按学号顺序升序排列；<br />
SELECT * FROM STUDENT ORDER BY NO DESC;<br />
(7) 将所有学生按学号顺序升序排列；<br />
SELECT * FROM STUDENT ORDER BY NO ASC; </p>
<p><br />
</p>
<img src ="http://www.blogjava.net/renyangok/aggbug/82283.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:31 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82283.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Hsql尝试</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82285.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:31:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82285.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82285.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82285.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82285.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82285.html</trackback:ping><description><![CDATA[（转自：转自：<a href="http://cutelife.bokee.com/blog/3474380.html">http://cutelife.bokee.com/blog/3474380.html</a>）<br />前言：该文章只是简单介绍一下hsql的入门内容，如果想仔细了解的话，参考官方帮助文档最为有用。 
<p>一、简介：<br />hsql数据库是一款纯Java编写的免费数据库，许可是BSD-style的协议，如果你是使用Java编程的话，不凡考虑一下使用它，相对其他数据库来说，其体积小，才563kb。仅一个hsqldb.jar文件就包括了数据库引擎，数据库驱动，还有其他用户界面操作等内容。在Java开源世界里，hsql是极为受欢迎的（就Java本身来说），JBoss应用程序服务器默认也提供了这个数据库引擎。由于其体积小的原因，又是纯Java设计，又支持SQL99，SQL2003大部分的标准，所以也是作为商业应用程序展示的一种选择。请到以下地址下载hsql： <a href="http://prdownloads.sourceforge.net/hsqldb/hsqldb_1_7_3_3.zip?download">http://prdownloads.sourceforge.net/hsqldb/hsqldb_1_7_3_3.zip?download</a></p><p>二、使用hsql数据库：<br />1、hsql数据库引擎有几种服务器模式：常用的Server模式、WebServer模式、Servlet模式、Standlone模式、Memory-Only数据库。<br />2、最为常用的Server模式：<br />1)首先却换到lib文件夹下，运行java -cp hsqldb.jar org.hsqldb.Server -database.0 db/mydb -dbname.0 xdb<br />执行命令后，将会在db文件夹下创建一个数据库mydb，别名（用于访问数据库）是xdb，如果存在mydb数据库，将会打开它。<br />2)运行数据库界面操作工具：java -cp hsqldb.jar org.hsqldb.util.DatabaseManager<br />在Type 选项里选上相应的服务器模式，这里选择HSQL Database Engine Server模式；Driver不用修改；URL修改为jdbc:hsqldb:hsql://localhost/xdb （主要这里xdb就是上面我们设置的别名）;user里设置用户名，第一次登录时，设置的是管理员的用户名，password设置密码。然后点击Ok。<br />3)第一次运行数据库引擎，创建数据库完毕。好了，你可以打开db文件夹，会发现里面多了几个文件。<br />mydb.properties文件：是关于数据库的属性文件。<br />mydb.script：hsql主要保存的表（这里按hsql的说法是Memory表，就是最为常用的），里面的格式都是文本格式，可以用文本查看，里面的语句都是sql语句，熟悉sql语句的话，你也可以手动修改它。每次运行数据库引擎的话都是从这里加载进内存的。<br />mydb.lck表示数据库处于打开状态。<br />其他的请参看hsqldb包里的手册。</p><p>3、WebServer模式和Server运行模式基本一样，只是支持了Http等协议，主要用于防火墙，默认端口是9001。启动Server，java -cp hsqldb.jar org.hsqldb.WebServer ...剩余的和上面的一致。</p><p>4、Servlet模式可以允许你通过Servlet容器来访问数据库，请查看hsqlServlet.java的源代码，和WebServer类似。</p><p>5、另一个值得思考的模式是Standalone模式：不能通过网络来访问数据库，主要是在一个JVM中使用，那样的话，访问的速度会更加快。虽然文档里面提到主要是用于开发时使用，但是我们可以假设一下，该方法不需要一个引擎类的东西，而类似于打开文件的方式，返回一个Connection对象：<br />Connection c = DriverManager.getConnection("jdbc:hsqldb:file:mydb", "sa", "");<br />将会在当前目录找到mydb数据库相关文件，打开并返回一个Connection对象。该方式有点好处就是可以不使用引擎，在需要的时候操作数据。所以那些对数据库不是特别有要求的，但又需要一个操作数据库的方式的话，可以使用这种方法。对于那些不想额外在数据库引擎花费金钱的话，可以使用这种方法。但是不推荐使用该方法。记得Hibernate里SessionFactory可以使用openSession(Connecttion c)来获得一个Session对象的，因此，在测试或者实际应用的话都可以这样使用。</p><p>6、Memory-Only 数据库：顾名思义，主要是内存中使用，不用于保存数据。可以用于在内存中交换数据。</p><p>三、具体的链接与操作的话，和一般的JDBC操作一样。而相应的Server模式的话，连接地址主要你运行数据库界面操作工具时，在URL一栏时默认已经设好了，自己实习一下，对比其中参数。</p><p>这篇文章介绍大致内容很详细，不过也大都是从Hsql的帮助上翻译的，我有必要加入点新鲜的血液。<br />这篇文章美中不足的是缺少实战性，往往初学者第一步都走不出来，比如我。<br />我在实践中遇到的问题是打开数据库管理器怎么也连接不上数据库，总是说<br />java.sql.sqlException Socket create error<br />搞了一个晚上，到第二天早上清醒一下，想起来这个数据库应该在创建库之后，保持那个cmd窗口，在此过程中连接。<br />果然好用，也迈出了开拓Hsql的第一步。</p><p>另外不用在互联网上搜索别的介绍，Hsql自带的guide就已经很详细了。</p><img src ="http://www.blogjava.net/renyangok/aggbug/82285.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:31 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82285.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Oracle数据库学习笔记（不断更新）</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82282.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:30:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82282.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82282.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82282.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82282.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82282.html</trackback:ping><description><![CDATA[1、DATE类型可以表示年月日时分秒，而TIMESTAMP不仅可以表示DATE类型，也可以表示毫秒，更精确。<br /><br />2、用plsql developer登陆oracle时，提示“ORA-28000: the account is locked”：<br />用sys用户登陆，登录方式为SYSDBA,然后把你要用的那个用户解锁:<br />alter user username account unlock;<br /><br /><span id="ArticleContent1_ArticleContent1_lblContent"><div>3、Start with...Connect By子句递归查询一般用于一个表维护树形结构的应用</div><div>创建示例表：</div><div>CREATE TABLE TBL_TEST<br />(<br />  ID    NUMBER,<br />  NAME  VARCHAR2(100 BYTE),<br />  PID   NUMBER                                  DEFAULT 0<br />);</div><div> </div><div>插入测试数据：</div><div>INSERT INTO TBL_TEST(ID,NAME,PID) VALUES('1','10','0');<br />INSERT INTO TBL_TEST(ID,NAME,PID) VALUES('2','11','1');<br />INSERT INTO TBL_TEST(ID,NAME,PID) VALUES('3','20','0');<br />INSERT INTO TBL_TEST(ID,NAME,PID) VALUES('4','12','1');<br />INSERT INTO TBL_TEST(ID,NAME,PID) VALUES('5','121','2');</div><div> </div><div>从Root往树末梢递归</div><div>select * from TBL_TEST<br /> start with id=1<br /> connect by prior id = pid</div><div> </div><div><div>从末梢往树ROOT递归</div><div>select * from TBL_TEST<br /> start with id=5<br /> connect by prior pid = id</div></div></span><img src ="http://www.blogjava.net/renyangok/aggbug/82282.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:30 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82282.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>结构化数据和非结构化数据的区别</title><link>http://www.blogjava.net/renyangok/archive/2006/11/20/82281.html</link><dc:creator>保尔任</dc:creator><author>保尔任</author><pubDate>Mon, 20 Nov 2006 07:29:00 GMT</pubDate><guid>http://www.blogjava.net/renyangok/archive/2006/11/20/82281.html</guid><wfw:comment>http://www.blogjava.net/renyangok/comments/82281.html</wfw:comment><comments>http://www.blogjava.net/renyangok/archive/2006/11/20/82281.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/renyangok/comments/commentRss/82281.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/renyangok/services/trackbacks/82281.html</trackback:ping><description><![CDATA[
		<font size="2">      在信息社会，信息可以划分为两大类。一类信息能够用数据或统一的结构加以表示，我们称之为结构化数据，如数字、符号；而另一类信息无法用数字或统一的结构表示，如文本、图像、声音、网页等，我们称之为非结构化数据。结构化数据属于非结构化数据，是非结构化数据的特例。 <br /><br />　　随着网络技术的发展，特别是Internet和Intranet技术的飞快发展，使得非结构化数据的数量日趋增大。这时，主要用于管理结构化数据的关系数据库的局限性暴露地越来越明显。因而，数据库技术相应地进入了“后关系数据库时代”，发展进入基于网络应用的非结构化数据库时代。所谓非结构化数据库，是指数据库的变长纪录由若干不可重复和可重复的字段组成，而每个字段又可由若干不可重复和可重复的子字段组成。简单地说，非结构化数据库就是字段可变的数据库。 </font>
<img src ="http://www.blogjava.net/renyangok/aggbug/82281.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/renyangok/" target="_blank">保尔任</a> 2006-11-20 15:29 <a href="http://www.blogjava.net/renyangok/archive/2006/11/20/82281.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>