当前位置：首页 > 范文大全 > 实用文>update 子查询使用介绍

update 子查询使用介绍

2022-06-04 07:43:51 收藏本文下载本文

“给公主盖海景房”通过精心收集，向本站投稿了19篇update 子查询使用介绍，下面小编给大家整理后的update 子查询使用介绍，欢迎阅读!

update 子查询使用介绍

篇1：update 子查询使用介绍

这篇文章主要介绍了update 子查询使用介绍,需要的朋友可以参考下

基础知识

1，关联子查询和非关联子查询

在非关联子查询中，内部查询只执行一次并返回它的值给外部查询，然后外部查询在它的处理中使用内部查询返回给它的值，而在关联子查询中，对于外部查询返回的每一行数据，内部查询都要执行一次。另外，在关联子查询中是信息流是双向的。外部查询的每行数据传递一个值给子查询，然后子查询为每一行数据执行一次并返回它的记录。然后，外部查询根据返回的记录做出决策。

如：

SELECT o1.CustomerID, o1.OrderID, o1.OrderDateFROM Orders o1WHERE o1.OrderDate = (SELECT Max(OrderDate)FROM Orders o2WHERE o2.CustomerID = o1.CustomerID)

是一个关联子查询

SELECT o1.CustomerID, o1.OrderID, o1.OrderDateFROM Orders o1WHERE o1.OrderDate IN(SELECT TOP 2 o2.OrderDateFROM Orders o2WHERE o2.CustomerID = o1.CustomerID)ORDER BY CustomerID

是一个非关联子查询

2，提示（HINT）

一般在优化时，无论采用基于规则的或是基于代价的方法，由Oracle系统的优化器来决定语句的执行路径。这样的选择的路径不要见得是最好的。所以，Oracle提供了一种方法叫提示的方法。它可以让编程人员按照自己的要求来选择执行路径，即提示优化器该按照什么样的执行规则来执行当前的语句。这样可以在性能上比起Oracle优化自主决定要好些。

通常情况下，编程人员可以利用提示来进行优化决策。通过运用提示可以对下面内容进行指定：

l SQL语句的优化方法；

l 对于某条SQL语句，基于开销优化程序的目标；

l SQL语句访问的访问路径；

l 连接语句的连接次序；

l 连接语句中的连接操作。

如果希望优化器按照编程人员的要求执行，则要在语句中给出提示。提示的有效范围有限制，即有提示的语句块才能按照提示要求执行。下面语句可以指定提示：

l 简单的SELECT ,UPDATE ,DELETE 语句；

l 复合的主语句或子查询语句；

l 组成查询（UNION）的一部分。

提示的指定有原来的注释语句在加“+”构成。语法如下：

[ SELECT | DELETE|UPDATE ] /*+ [hint | text ] */

或

[ SELECT | DELETE|UPDATE ] --+ [hint | text ]

注意在“/*”后不要空就直接加“+”，同样 “--+”也是连着写。

警告：如果该提示语句书写不正确，则Oracle就忽略掉该语句。

常见的提示有：

Ordered 强制按照from子句中指定的表的顺序进行连接

Use_NL 强制指定两个表间的连接方式为嵌套循环（Nested Loops）

Use_Hash 强制指定两个表间的连接方式为哈希连接（Hash Join）

Use_Merge 强制指定两个表间的连接方式为合并排序连接（Merge Join）

Push_Subq 让非关联子查询提前执行

Index 强制使用某个索引

3，执行计划

在PL/SQL Developer的SQL WINDOWS中用鼠标或键盘选中SQL语句，然后按F5，就会出现执行计划解析的界面：

4， Update的特点

Update的系统内部执行情况可以参照附文：对update事务的内部分析.doc

使用Update的基本要点就是，

1）尽量使用更新表上的索引，减少不必要的更新

2）更新的数据来源花费时间尽可能短，如果无法做到就把更新内容插入到中间表中，然后给中间表建上索引，再来更新

3）如果更新的是主键，建议删除再插入。

5，示例用表

后面的阐述将围绕以下两张表展开：

Create table tab1 (workdate varchar2(8), cino varchar2(15), val1 number, val2 number);

Create table tab2 (workdate varchar2(8), cino varchar2(15), val1 number, val2 number);

Create table tab3 (workdate varchar2(8), cino varchar2(15), val1 number, val2 number);

Create table tab4 (workdate varchar2(8), cino varchar2(15), val1 number, val2 number);

workdate, cino为两张表的关键字，默认情况没有建主键索引，

二，Update两种情况

用Update更新某个表，无外乎是两种情况：根据关联子查询，更新字段；通过非关联子查询，限定更新范围。如果还有第三种情况，那就是前两种情况的叠加。

1，根据关联子查询，更新字段

Update tab1 tSet (val1, val2) = (select val1, val2from tab2where workdate = t.workdateand cino = t.cino);

通过tab2来更新tab1的相应字段。执行SQL语句时，系统会从tab1中一行一行读记录，然后再通过关联子查询，找到相应的字段来更新。关联子查询能否通过tab1的条件快速的查找到对应记录，是优化能否实现的必要条件。所以一般都要求在tab2上建有Unique或者排重性较高的Normal索引。执行所用时间大概为（查询tab1中一条记录所用的时间 + 在tab2中查询一条记录所用的时间）* tab1中的记录条数。

如果子查询条件比较复杂，如以下语句：

Update tab1 tSet (val1, val2) = (select val1, val2from tab2 ttwhere exists (select 1from tab3where workdate = tt.workdateand cino = tt.cino)and workdate = t.workdateand cino = t.cino);

这时更新tab1中的每条记录花费在子查询上的时间将成倍增加，如果tab1中的记录数较多，这种更新语句几乎是不可完成。

解决方式是，把子查询提取出来，做到中间表中，然后给中间表建上索引，用中间表来代替子查询，这样速度就能大大提高：

Insert into tab4select workdate, cino, val1, val2from tab2 ttwhere exists (select 1from tab3where workdate = tt.workdateand cino = tt.cino);create index tab4_ind01 on tab4(workdate, cino);Update tab1 tSet (val1, val2) = (select val1, val2from tab4 ttwhere workdate = t.workdateand cino = t.cino);

2，通过非关联子查询，限定更新范围

Update tab1 tset val1 = 1where (workdate, cino) in (select workdate, cino from tab2)

根据tab2提供的数据范围，来更新tab1中的相应记录的val1字段。

在这种情况下，系统默认执行方式往往是先执行select workdate, cino from tab2子查询，在系统中形成系统视图，然后在tab1中选取一条记录，查询系统视图中是否存在相应的workdate, cino组合，如果存在，则更新tab1，如果不存在，则选取下一条记录。这种方式的查询时间大致等于：子查询查询时间 + （在tab1中选取一条记录的时间 + 在系统视图中全表扫描寻找一条记录时间）* tab1的记录条数。其中“在系统视图中全表扫描寻找一条记录时间”会根据tab2的大小而有所不同。若tab2记录数较小，系统可以直接把表读到系统区中；若tab2记录数多，系统无法形成系统视图，这时会每一次更新动作，就把子查询做一次，速度会非常的慢。

针对这种情况的优化有两种

1）在tab1上的workdate, cino字段上加入索引，同时增加提示。

修改以后的SQL语句如下：

Update /*+ordered use_nl(sys, t)*/ tab1 tset val1 = 1where (workdate, cino) in (select workdate, cino from tab2)

其中sys表示系统视图。如果不加入ordered提示，系统将会默认以tab1表作为驱动表，这时就要对tab1作全表扫描。加入提示后，使用系统视图，即select workdate, cino from tab2，作为驱动表，在正常情况下，速度能提高很多。

2）在tab2表上的workdate, cino字段加入索引，同时改写SQL语句：

Update tab1 tset val1 = 1where exists (select 1from tab2where workdate = t.workdateand cino = t.cino)

三，索引问题

update索引的使用比较特殊，有时看起来能用全索引，但实际上却只用到一部分，所以建议把复合索引的各字段写在一起。

例如：

Update /*+ordered use_nl(sys, t)*/ tab1 tset val1 = 1where cino in (select cino from tab2)and workdate = ‘06‘

这条SQL语句是不能完全用到tab1上的复合索引workdate + cino的。能用到的只是workdate=‘200506‘的约束。

如果写成这样，就没问题：

Update /*+ordered use_nl(sys, t)*/ tab1 tset val1 = 1where (workdate, cino) in (select workdate, cino from tab2)

篇2：跟我学SQL：(三)使用SQL子选择来合并查询

你是否曾经为了得到所需要的信息而反复查询？子选择，也被称为子查询，也许正是你在寻找的，SQL的这项功能使你可以在一组结果中查询，创造性地给结果组加以限定，或是在向数据库的单一调用中将结果与一个无关系的查询做相关。这篇文章中我将给出几个子选择的例子并就何时使用他们进行讨论。

在一个结果组中搜索

子选择的理念很简单：一个选择查询安置在另一个查询内部，创建一个在单一声明搜索中不可用的资源。子选择允许查询的合并，结果组比较的责任落到了数据库中而不是应用软件代码中。

使用这个功能的一个途径是对两个表格中的可比数据专栏中的值进行定位。例如，我的一个数据库有两个表格，Album和Lyric。我可以很容易地通过下面的子查询声明来找到每一个Metallica的歌曲中包含“justice”的歌名：

SELECT song_name FROM Album

WHERE band_name = ‘Metallica’

AND song_name IN

(SELECT song_name FROM Lyric

WHERE song_lyric LIKE ‘%justice%’);

这个例子是很简单的，我从Album表格中选择了所有Metallica的歌曲，接着，我在lyric表格中选择所有包含“justice”的歌曲，最后，我使用IN关键字来从Lyric表格结果组中显示的Album表格中返回歌曲名称。

我使用Lyric表格结果组来给Album表格中的结果做限定。WHERE子句中的子选择部分是完全自包含的，因此我不需要使用例如Album.song_name和Lyric.song_name等完整的专栏名称。我没有从最终结果组的Lyric表格中返回任何值，如果我需要歌曲的Lyric，我会使用一个JOIN声明。

使用NOT IN排除结果

你可以使用NOT IN关键字来获得明确地不被包含在另一个结果组中的结果。例如，我想要通过下面的代码来返回Metallica在“And Justice for All”专辑中不包含单词“justice”的歌曲：

SELECT song_name FROM Album

WHERE album_name = ‘And Justice for All’

AND band_name = ‘Metallica’

AND song_name NOT IN

(SELECT song_name FROM Lyric

WHERE song_lyric LIKE ‘%justice%’);

在前面的SQL代码中，我选择了Metallica的“And Justice for All,”专辑中的所有歌曲，接着是带有歌词中带有“justice”所有歌曲，最后从在Lyric结果组中没有出现的Album结果组返回了所有歌曲。较之于返回两个查询并使用代码来比较数组，你通过一个单独的声明就可以得到确切的结果。

使用EXISTS来相关结果

有时你可以通过多种途径来访问相同的数据，而且你需要对你的结果进行匹配（或相关）来得到值的交叉区。例如，我可以通过搜索Album表格来得到Metallica的歌曲列表，可是，我也可以从我的Cover表格中得到由Damage, Inc表演的Metallica的歌曲的列表，我可以在两个表格中直接比较查询结果来对值作相关。

SELECT Album.song_name FROM Album

WHERE Album.band_name = ‘Metallica’

AND EXISTS

(SELECT Cover.song_name FROM Cover

WHERE Cover.band_name = ‘Damage, Inc.’

AND Cover.song_name = Album.song_name);

在SQL代码中，我使用完整的专栏名称，这是因为我直接对两个表格作比较，而不仅仅是将结果组作为一个被动资源来使用，

我并不从Cover表格中返回结果。一些数据库支持NOT EXISTS关键字来确保你并没有匹配。

使用合计函数来比较

除了使用子选择在相关的表格中检查数据，你还可以在一个WHERE子选择中使用合计函数来确定主结果组。例如，我想要核实每一个Metallica歌曲在Album表格中的条目。而且，我还想返回缺少歌曲的专辑的名称。很方便地，AlbumInfo表格包含的一个专栏(album_tracks)给出了应该有多少首歌曲方面的信息。

SELECT AlbumInfo.album_name FROM AlbumInfo

WHERE AlbumInfo.band_name = ‘Metallica’

AND album_tracks

(SELECT COUNT(*) FROM Album

WHERE Album.album_name = AlbumInfo.album_name);

现在我已经成功地返回了所有Metallica的专辑中，应有的曲目数量与Album表格中实际的歌曲条目数量不符的专辑名称。

返回子选择结果

如果我还是关心每一张专辑的曲目数量并需要得到一个比较报告怎么办？你可以将一个子选择的结果作为最终结果组的一部分来返回。这个功能经常被合计函数所使用。通常地，对其他表格的访问可以作为你的查询的一部分。下一个例子将返回每一张Metallica的专辑，应该包括的曲目数量和在Album表格中包括的条目数量：

SELECT AlbumInfo.album_name, album_tracks,

(SELECT COUNT(*) FROM Album

WHERE Album.album_name = AlbumInfo.album_name)

FROM AlbumInfo

WHERE AlbumInfo.band_name = ‘Metallica’;

另一个强有力的例子涉及了在AlbumInfo表格中将album_tracks值改变为在Album表格中实际的条目数量：

UPDATE AlbumInfo SET album_tracks =

SELECT COUNT(*) FROM Album

WHERE AlbumInfo.album_name = Album.album_name)

WHERE AlbumInfo.band_name = ‘Metallica’;

在上两个例子中的子选择声明被看作一个自包含单位来执行。

子选择比较关键字(ALL, SOME, ANY)

除了使用标准查询功能，还有三个关键字可以使你将一个表达式值和一个单栏子选择声明结果组作比较，这些关键字返回TRUE或FALSE的Boolean值。ALL关键字要求子选择中所有值都遵守比较运算符。SOME和ANY关键字则要求至少一对。这里是ALL关键字的一个简单实例。

SELECT * FROM AlbumSales

WHERE album_gross >

ALL (SELECT album_costs FROM AlbumProduction);

上面的例子将从AlbumSales表格返回在AlbumProduction表格里面付出总额大于成本而生产最昂贵的专辑的所有记录。如果用ANY替代ALL，声明将返回所有付出总额大于最低专辑成本的专辑记录。声明= ANY与IN关键字意义是相同的。声明 ALL与NOT IN关键字是对等的。关键字ANY和SOME也是等同的。数据库生产商中对这些关键字的支持情况是不同的，因此在出现问题时要相信查阅生产商方面的资料。

谁对标准化数据结构有疑问？

子选择查询句法是简单易懂的，而懂得何时使用它却是一个难点。如果你曾经在标准化数据结构方面出现问题，子选择声明将帮助你获得更深入的了解。

篇3：如何使用微信查询快递

微信也可以查快递了，快拿起手机来扫一扫试试吧。最全面的快递查询，可以随时随地查询到您的快递状态，支持顺丰快递、申通快递、圆通快递、中通快递、韵达快递、天天快递、EMS、宅急送等等主流快递的运单查询。一定能帮助到您

工具/原料

能装微信的智能手机

微信

方法/步骤

1打开微信，使用扫一扫或者直接关注“星罗快递查询”

2想星罗快递查询发送快递编号

3成功

工具：点击下载微信

实际上你只要关注查快递的微信公众账号就可以了。比如快递100或者查快递

要查快递的时候，进入公众号的聊天信息界面，直接输入你的快递单号，如果是不常用的快递公司单号，可以输“快递公司+单号”

这时就会出现你快递的信息

[如何使用微信查询快递]

篇4：如何使用Internet的查询工具

如何使用Internet的查询工具

Internet就像一个浩瀚的知识海洋,里面蕴藏着取之不尽的信息宝藏。如何挖掘开采它,获得人们需要的东西,目前还存在着两方面的问题:首先,人们手头的查询工具太多,有WWW(World Wide Web)、Gopher、FTP以及不计其数的专题新闻组、消息表等等;其次,Internet网上的资源没有确定的分类,人们要查找的是一堆毫无组织、地址不唯一的信息。同时,那些热心的程序员、厂商、经纪人还在源源不断地往Internet上填充着他们的东西。这无形中给检索工作带来了很大难度,没有一定的方法,在Internet上查询信息犹如大海捞针。哪种情况

下该用什么样的工具帮你简便快捷地找到你想要的信息,看了本文以后,或许会对你有所帮助。

目录帮助

假如你要查找人们普遍感兴趣的题目,如内战或者热线财经一类的消息并找到其网络地址,通常这类目录会很大,而且有按专题组织的地址表。这种情况下,我们一般喜欢用Yahoo(地址:www.yahoo.com/)查找,它列出了8万个网络地址(包括Web页、Gophers、FTP地址以及Usenet新闻组),顶层又按艺术、计算机、卫生、保健等分成14类子题目。用鼠标点一下就可以选定子题目表,反复地查找子表,直到你找到需要的信息为止。

除了Yahoo一类人们普遍感兴趣的目录外,专题目录则覆盖了从古文物到青年工人等各方面的信息。找到这些专用目录的最佳途径是可以去密执根大学(地址:www.lib.mich. edu/chhome.html)查找那里的Clearinghouse,那里有面向专题的Internet资源指南。

查询引擎

当人们意欲查询Web提供的信息时,目录项是非常有用的,用户的问题越专有,待查的目录项就越少。为了取得问题的答案,人们必须使用查询引擎。查询引擎实际上是一些Web页,你可以在其中输入你想要查找的文本串。按一下按钮,等一会儿,引擎就会识别出与输入的关键字匹配的`Web地址表。在最近的Web查询扫描中,我们查到60个这样的页,其中只有10页是我们觉得有用的工具,其余的用处不大,或者只有计算机科学专业的研究生对之感兴趣。

每一个查询引擎代表一个数据库,里面含有Web页的URL(Universal Resource Locator或经专门格式化后的Internet地址)地址以及其他网络资源。大多数查询引擎数据库是由Crawler程序、漫游Web的软件程序通过页与页的连接顺次查找新的地址搜集而来的。这里,Crawler又被称为机器人或蜘蛛。当蜘蛛找到新的页时,就把新页增加到数据库中。

这些数据库存有成千上万个Web页,在引擎头的位置每天都在增加新的页。其中,多数人感兴趣的引擎如Lycos和Excite覆盖面最广,其中每个数据库有150万个索引Web页,其次是Open Text Index,据称也有130万个Web页。

每个数据库引擎的大小对查找是否成功起着很大的作用,例如,我们想用字符串recipewheat Beer(酿啤酒秘诀)查询每一个引擎,其结果是:最大的Lycos数据库引擎提供给我们437个匹配页(hit),InfoSeek和Open Text Index数据库则每次提供200个页,用其他数据库则少于100页,有几种情况下,甚至查不到一个Web页。通常的情形是,数据库越小,查到的Web页就越少。

大多数数据库引擎严格限制其只能检索Web本身,InfoSeek和Excite则比其他引擎更进一步,它们增加了Usenet新闻组索引。InfoSeek还允许用户查询就近的一组非Internet数据库的信息。

索引中的信息

Web的蜘蛛程序比URL采集信息做得要多一些,它们还搜集有关每一页的信息,一旦你提交一个查询,查询引擎的backend软件就建立起一个你所需信息的索引。从一个引擎到另外一个引擎,其索引技术是各不相同的,你不要因此感到奇怪。

在每个引擎中,都有一个页的索引URL地址和题目。多数引擎还有每一段的索引标题,其他的引擎则只是记录了频繁提到的词或者文本的头几行。在Open Text Index数据库引擎中,页的每一个单词都有索引,甚至包括and一类别的引擎忽略的词也有。结果可想而知,它理所当然成了唯一能在查找过程中返回是或

[1] [2] [3]

篇5：下一代系统更新服务器Windows update 介绍网络服务器

Windows Update Services（WUS2.0）是新的系统补丁发放服务器名称，它是属于Software Update Services(SUS1.0)的升级版本， WUS和SUS1.0相比，主要提供了除了可以对Windows产品发放补丁外，还可以对Office、 SQL Server和其他微软产品进行补丁分发；同时该

Windows Update Services（WUS2.0）是新的系统补丁发放服务器名称，它是属于Software Update Services(SUS1.0)的升级版本。WUS和SUS1.0相比，主要提供了除了可以对Windows产品发放补丁外，还可以对Office、SQLServer和其他微软产品进行补丁分发；同时该服务器同样将是免费的组件；

WUS中新增加的内容除了上面介绍的更多产品支持外还有：改良的管理员控制处理，减少网络带宽影响和使用、发布剩余报告信息功能、对最终用户的优化、增加管理员管理功能，总共包括了6个方面的内容。下面我们仔细对每个特性进行详细说明；

支持服务器系统包括：Windows Server +SP4和Windows Server ;

支持客户端系统包括：Windows 2000 +SP4、WindowsXP和Windows Server 2003;

◆ 更新更多的微软产品

WUS和SUS不同，WUS拥有可以对微软所有的产品提供更新的功能；初始安装后,WUS将支持Windows、Office、SQL Server、Exchange以及MSDE各种版本的更新，其他微软的产品更新需要启动使用；

◆ 改良的管理员控制处理

WUS意味着扩大范围和距离功能和控制更新管理，稍描缺少更新补丁的系统被集成解决方案，单一的稍描缺少补丁的和允许让管理员方便的决定是否将该补丁配置给目标系统；

◆ 减少网络带宽影响和使用

WUS核心是包括：Windows BITS(后台智能传输服务)集成和Windows Installer Service，这样可以最小化的使用空余网络传输下载，这样占用最少的带宽资源，

同时支持点断下载。

◆ 发布剩余报告信息功能

WUS设置一些基本的报表，允许管理员很容易的制定出系统健康状况和更新情况的图形报表。管理员可以阅览这些报表，可以知道更新对象更新情况：很好、失败、错误和详细信息；WUS日志可以记录在系统或者配置到SQL Server或者MSDE中。

◆ 对最终用户的优化

WUS提供最少用户工作消耗和最优化用户界面，对于不需要重新启动更新系统，系统可以自动隐藏安装和设置系统更新；对于需要重新启动更新系统，WUS将多种这样需要重新启动更新一次部署到你的系统中，只重新启动一次。同时WUS提供了多用户语言的支持，支持任何一种语言操作系统的更新。

◆ 增加管理员管理功能

WUS在分布式环境中提供了集中的、可升级的管理，包括新的管理界面让管理员更加容易配置、管理、解决问题、报表阅览。同时可以使用SQL Server 和MSDE的数据库储存相关系统设置、状况、更新和元数据。可以提高备份和恢复的能力。而且整个分布式管理基于一个管理界面，客户端可以通过域控制器的组策略统一的管理，并且WUS允许脚步和命令行的控制。

补充提示：

WUS非常适合中小型组织对于系统补丁升级的需求，但是如果是需要对于大型网络系统的综合管理微软的System Management Server 2003更适合；同时如果网络中部署了SMS 2003将没有必要再部署WUS。

原文转自：www.ltesting.net

篇6：insert into … on duplicate key update / replace into 多行数据介绍

-08-08超详细mysql left join,right join,inner join用法分析

-11-11Mysql 自动增加设定基值的语句

-06-06win2003 mysql单向同步配置步骤[已测]

2011-01-01MYSQL数据表损坏的原因分析和修复方法小结(推荐)

-11-11MyEclipse通过JDBC连接MySQL数据库基本介绍

-06-06MariaDB(Mysql分支)my.cnf配置文件中文注释版

2014-06-06MySQL事务处理与应用简析

-03-03MYSQL索引建立需要注意以下几点细节

-06-06mysql 存储过程的问题

2010-04-04MySQL show命令的用法

篇7：insert into … on duplicate key update / replace into 多行数据介绍

热点排行

mysql安装图解 mysql图文安装教程

超详细mysql left join,right jo

Can''t connect to MySQL server

Mysql命令行导入sql数据

MYSQL 数据库导入导出命令

Mysql字符串截取函数SUBSTRING的

MySQL数据库备份与恢复方法

MySQL server has gone away 问题

windows下mysql忘记root密码的解

MySQL日期数据类型、时间类型使用

篇8：1227一次关于子查询的优化

一条SQL执行接近两分钟，一看便知子查询非常多，可以先使用调优利器dbms_xplan.display_cursor，

SQL>alter session set statistics_level=all;

SQL>set pagesize 100

SQL>SELECT *

FROM (SELECT unpaged_.*, rownum rn_

FROM (select t2.*,

(select cs.system_name

from cfms_sys cs

where cs.sys_id = t2.system_id) as system_name,

(select m.name

from cfms_module m

where m.module_id = t2.module_id) as module_name,

(select count(1)

from cfms_replys cr

where cr.question_id = t2.id) reply_count,

(select v.version_no

from cfms_versions v

where v.version_id = t2.ps_online_version) as ps_online_version_no,

(select to_char(wmsys.wm_concat(t.tag_id || ';' ||

t.name))

from cfms_tag t, cfms_tag_question tq

where t2.id = tq.question_id

and t.tag_id = tq.tag_id) as tags,

(select u.name

from v_user u

where u.user_id = t2.service_id) as service_name,

(select max(m.modify_at)

from cfms_question_modify m

where m.question_id = t2.id) as modify_at,

decode((select count(1)

from cfms_questions cq,

cfms_question_workflow cqw,

bpms_ru_todo_taskbrtt

where cq.id = cqw.question_id

and cqw.process_ins_id =

brtt.cur_process_ins_id

and cq.id = t2.id

and brtt.trans_actor_id = 'N00251.sz'),

1) as can_handle

from cfms_questions t2

where t2.state -1

and exists

(select 1

from cfms_questions cq,

cfms_question_workflow cqw,

bpms_ru_todo_taskbrtt

where cq.id = cqw.question_id

and cqw.process_ins_id = brtt.cur_process_ins_id

and cq.id = t2.id

and brtt.trans_actor_id = 'N00251.sz')

order by t2.discover_time desc, t2.id) unpaged_

WHERE rownum <= 30)

WHERE rn_ > 20；

已用时间: 00: 01: 53.13

SQL>select * from table(dbms_xplan.display_cursor(null,null,'allstats last'));

关于下面列的解释，请看blog.csdn.net/stevendbaguo/article/details/13776221 ，初步判断子查询次数太多（看Starts便知），很多表都是全表扫描太多次导致。对相应的表加上索引后，有些子查询还是很慢，现在不得不使用神器10046 。

----------------------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------

| 0 | SELECT STATEMENT ||1 | | 10 |00:01:59.41 | 2244K| | | |

| 1 | TABLE ACCESS BY INDEX ROWID | CFMS_SYS |3 |1 |3 |00:00:00.01 | 5 | | | |

|* 2 | INDEX UNIQUE SCAN| CFMS_SYS_PK|3 |1 |3 |00:00:00.01 | 2 | | | |

| 3 | TABLE ACCESS BY INDEX ROWID | CFMS_MODULE|5 |1 |4 |00:00:00.01 | 6 | | | |

|* 4 | INDEX UNIQUE SCAN| CFMS_MODUL |5 |1 |4 |00:00:00.01 | 2 | | | |

| 5 | SORT AGGREGATE || 4368 |1 | 4368 |00:00:00.29 | 26208 | | | |

|* 6 | TABLE ACCESS FULL| CFMS_REPLYS| 4368 |3 |0 |00:00:00.25 | 26208 | | | |

|* 7 | TABLE ACCESS FULL | CFMS_VERSIONS |1 |1 |0 |00:00:00.01 | 6 | | | |

| 8 | SORT AGGREGATE || 4368 |1 | 4368 |00:00:01.08 | 26208 | | | |

|* 9 | HASH JOIN || 4368 |5 |0 |00:00:00.58 | 26208 | 821K| 821K| 221K (0)|

|* 10 | TABLE ACCESS FULL | CFMS_TAG_QUESTION| 4368 |5 |0 |00:00:00.19 | 26208 | | | |

| 11 | TABLE ACCESS FULL | CFMS_TAG |0 |9 |0 |00:00:00.01 | 0 | | | |

| 12 | MAT_VIEW ACCESS BY INDEX ROWID| V_USER |3 |1 |2 |00:00:00.01 | 5 | | | |

|* 13 | INDEX UNIQUE SCAN| PK_PUB_USER|3 |1 |2 |00:00:00.01 | 3 | | | |

| 14 | SORT AGGREGATE || 4368 |1 | 4368 |00:00:03.24 | 262K| | | |

|* 15 | TABLE ACCESS FULL| CFMS_QUESTION_MODIFY | 4368 |1 | 4378 |00:00:03.16 | 262K| | | |

| 16 | SORT AGGREGATE || 4368 |1 | 4368 |00:01:54.25 | 1928K| | | |

|* 17 | HASH JOIN || 4368 |1 | 4369 |00:01:54.19 | 1928K| 894K| 894K| 381K (0)|

| 18 | NESTED LOOPS || 4368 |1 | 4371 |00:00:03.04 | 268K| | | |

|* 19 | INDEX UNIQUE SCAN | CFMS_QUESTIONS | 4368 |1 | 4368 |00:00:00.09 | 6304 | | | |

|* 20 | TABLE ACCESS FULL | CFMS_QUESTION_WORKFLOW | 4368 |1 | 4371 |00:00:02.87 | 262K| | | |

|* 21 | TABLE ACCESS FULL | BPMS_RU_TODO_TASK| 4368 | 1424 | 19M|00:00:33.73 | 1659K| | | |

|* 22 | VIEW ||1 |1 | 10 |00:01:59.41 | 2244K| | | |

|* 23 | COUNT STOPKEY ||1 | | 30 |00:01:59.41 | 2244K| | | |

| 24 | VIEW||1 |1 | 30 |00:01:59.41 | 2244K| | | |

|* 25 | SORT ORDER BY STOPKEY||1 |1 | 30 |00:01:59.41 | 2244K| 80896 | 80896 |71680 (0)|

|* 26 |HASH JOIN RIGHT SEMI||1 |1 | 4368 |00:00:00.33 | 2065 | 1049K| 1049K| 1413K (0)|

| 27 | VIEW | VW_SQ_1 |1 | 1424 | 4377 |00:00:00.21 | 1811 | | | |

| 28 | NESTED LOOPS||1 | 1424 | 4377 |00:00:00.19 | 1811 | | | |

|* 29 | HASH JOIN ||1 | 1424 | 4377 |00:00:00.11 | 440 | 974K| 974K| 1446K (0)|

|* 30 | TABLE ACCESS FULL | BPMS_RU_TODO_TASK|1 | 1424 | 4386 |00:00:00.01 | 380 | | | |

| 31 | TABLE ACCESS FULL | CFMS_QUESTION_WORKFLOW |1 | 1674 | 5201 |00:00:00.02 |60 | | | |

|* 32 | INDEX UNIQUE SCAN| CFMS_QUESTIONS | 4377 |1 | 4377 |00:00:00.04 | 1371 | | | |

|* 33 | TABLE ACCESS FULL | CFMS_QUESTIONS |1 | 3774 | 5163 |00:00:00.04 | 254 | | | |

----------------------------------------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

2 - access(“CS”.“SYS_ID”=:B1)

4 - access(“M”.“MODULE_ID”=:B1)

6 - filter(“CR”.“QUESTION_ID”=:B1)

7 - filter(“V”.“VERSION_ID”=:B1)

9 - access(“T”.“TAG_ID”=“TQ”.“TAG_ID”)

10 - filter(“TQ”.“QUESTION_ID”=:B1)

13 - access(“U”.“USER_ID”=:B1)

15 - filter(“M”.“QUESTION_ID”=:B1)

17 - access(“CQW”.“PROCESS_INS_ID”=“BRTT”.“CUR_PROCESS_INS_ID”)

19 - access(“CQ”.“ID”=:B1)

20 - filter(“CQW”.“QUESTION_ID”=:B1)

21 - filter(“BRTT”.“TRANS_ACTOR_ID”='N00251.sz')

22 - filter(“RN_”>20)

23 - filter(ROWNUM<=30)

25 - filter(ROWNUM<=30)

26 - access(“ITEM_1”=“T2”.“ID”)

29 - access(“CQW”.“PROCESS_INS_ID”=“BRTT”.“CUR_PROCESS_INS_ID”)

30 - filter(“BRTT”.“TRANS_ACTOR_ID”='N00251.sz')

32 - access(“CQ”.“ID”=“CQW”.“QUESTION_ID”)

33 - filter(“T2”.“STATE”(-1))

10046trace的结果是(如何使用10046请看我以前的blog)，通过神器10046一眼就可以看出是对BPMS_RU_TODO_TASK这个子查询查询太多次，表了也有点大：

Rows Row Source Operation

------- ---------------------------------------------------

3 TABLE ACCESS BY INDEX ROWID CFMS_SYS (cr=5 pr=0 pw=0 time=156 us cost=1 size=52 card=1)

3 INDEX UNIQUE SCAN CFMS_SYS_PK (cr=2 pr=0 pw=0 time=70 us cost=0 size=0 card=1)(object id 132684)

4 TABLE ACCESS BY INDEX ROWID CFMS_MODULE (cr=6 pr=0 pw=0 time=161 us cost=1 size=50 card=1)

4 INDEX UNIQUE SCAN CFMS_MODUL (cr=2 pr=0 pw=0 time=70 us cost=0 size=0 card=1)(object id 132664)

4370 SORT AGGREGATE (cr=3 pr=0 pw=0 time=84950 us)

0 INDEX RANGE SCAN IND_CR_QUESTION_ID (cr=3 pr=0 pw=0 time=48849 us cost=1 size=51 card=3)(object id 134801)

0 TABLE ACCESS FULL CFMS_VERSIONS (cr=6 pr=0 pw=0 time=85 us cost=3 size=42 card=1)

4370 SORT AGGREGATE (cr=4370 pr=0 pw=0 time=986114 us)

0 HASH JOIN (cr=4370 pr=0 pw=0 time=499642 us cost=7 size=485 card=5)

0 TABLE ACCESS BY INDEX ROWID CFMS_TAG_QUESTION (cr=4370 pr=0 pw=0 time=128932 us cost=3 size=270 card=5)

0 INDEX RANGE SCAN IND_TQ_QUESTION_ID (cr=4370 pr=0 pw=0 time=57400 us cost=1 size=0 card=5)(object id 134802)

0 TABLE ACCESS FULL CFMS_TAG (cr=0 pr=0 pw=0 time=0 us cost=3 size=387 card=9)

2 MAT_VIEW ACCESS BY INDEX ROWID V_USER (cr=5 pr=0 pw=0 time=137 us cost=2 size=17 card=1)

2 INDEX UNIQUE SCAN PK_PUB_USER (cr=3 pr=0 pw=0 time=81 us cost=1 size=0 card=1)(object id 134599)

4370 SORT AGGREGATE (cr=4034 pr=0 pw=0 time=236040 us)

4380 TABLE ACCESS BY INDEX ROWID CFMS_QUESTION_MODIFY (cr=4034 pr=0 pw=0 time=184813 us cost=4 size=26 card=1)

4380 INDEX RANGE SCAN IND_QM_QUESTION_ID (cr=1873 pr=0 pw=0 time=72275 us cost=1 size=0 card=3)(object id 134803)

4370 SORT AGGREGATE (cr=1673138 pr=0 pw=0 time=106229115 us)

4371 HASH JOIN (cr=1673138 pr=0 pw=0 time=106172615 us cost=32 size=118 card=1)

4373 NESTED LOOPS (cr=16908 pr=0 pw=0 time=294422 us cost=4 size=71 card=1)

4370 INDEX UNIQUE SCAN CFMS_QUESTIONS (cr=6308 pr=0 pw=0 time=70360 us cost=1 size=17 card=1)(object id 132669)

4373 TABLE ACCESS BY INDEX ROWID CFMS_QUESTION_WORKFLOW (cr=10600 pr=0 pw=0 time=164442 us cost=3 size=54 card=1)

4373INDEX RANGE SCAN IND_QW_QUESTION_ID (cr=6230 pr=0 pw=0 time=59792 us cost=1 size=0 card=1)(object id 134804)

19175560 TABLE ACCESS FULL BPMS_RU_TODO_TASK (cr=1656230 pr=0 pw=0 time=32077237 us cost=27 size=66928 card=1424)

10 VIEW (cr=1683632 pr=0 pw=0 time=108051153 us cost=104 size=4407 card=1)

30 COUNT STOPKEY (cr=1683632 pr=0 pw=0 time=108051028 us)

30 VIEW (cr=1683632 pr=0 pw=0 time=108050887 us cost=104 size=4394 card=1)

30 SORT ORDER BY STOPKEY (cr=1683632 pr=0 pw=0 time=108050758 us cost=104 size=375 card=1)

4370HASH JOIN RIGHT SEMI (cr=2065 pr=0 pw=0 time=325742 us cost=103 size=375 card=1)

4379 VIEW VW_SQ_1 (cr=1812 pr=0 pw=0 time=206454 us cost=35 size=24208 card=1424)

4379 NESTED LOOPS (cr=1812 pr=0 pw=0 time=188877 us cost=35 size=168032 card=1424)

4379 HASH JOIN (cr=439 pr=0 pw=0 time=102674 us cost=35 size=143824 card=1424)

4388 TABLE ACCESS FULL BPMS_RU_TODO_TASK (cr=379 pr=0 pw=0 time=14081 us cost=27 size=66928 card=1424)

5206 TABLE ACCESS FULL CFMS_QUESTION_WORKFLOW (cr=60 pr=0 pw=0 time=13333 us cost=7 size=90396 card=1674)

4379 INDEX UNIQUE SCAN CFMS_QUESTIONS (cr=1373 pr=0 pw=0 time=40158 us cost=0 size=17 card=1)(object id 132669)

5168 TABLE ACCESS FULL CFMS_QUESTIONS (cr=253 pr=0 pw=0 time=42738 us cost=68 size=1351092 card=3774)

定位到了问题就简单了，这是一个分页SQL，降低子查询的次数即可，将子查询提出来，则每次都只执行10次，执行时间立马将下来0.75s，

电脑资料

SQL> SELECT (select cs.system_name

2from cfms_sys cs

3 where cs.sys_id = unpaged.system_id) as system_name,

4 (select m.name

5from cfms_module m

6 where m.module_id = unpaged.module_id) as module_name,

7 (select count(1)

8from cfms_replys cr

9 where cr.question_id = unpaged.id) reply_count,

10 (select v.version_no

11from cfms_versions v

12 where v.version_id = unpaged.ps_online_version) as ps_online_version_no,

13 (select to_char(wmsys.wm_concat(t.tag_id || ';' || t.name))

14from cfms_tag t, cfms_tag_question tq

15 where unpaged.id = tq.question_id

16 and t.tag_id = tq.tag_id) as tags,

17 (select u.name from v_user u where u.user_id = unpaged.service_id) as service_name,

18 (select max(m.modify_at)

19from cfms_question_modify m

20 where m.question_id = unpaged.id) as modify_at,

21 decode((select count(1)

22from cfms_questions cq,

23 cfms_question_workflow cqw,

24 bpms_ru_todo_taskbrtt

25 where cq.id = cqw.question_id

26 and cqw.process_ins_id = brtt.cur_process_ins_id

27 and cq.id = unpaged.id

28 and brtt.trans_actor_id = 'N00251.sz'),

29 0,

30 0,

31 1) as can_handle

32 FROM (SELECT unpaged_.*, rownum rn_

33FROM (select t2.*

34 from cfms_questions t2

35 where t2.state -1

36 and exists

37 (select 1

38 from cfms_questions cq,

39 cfms_question_workflow cqw,

40 bpms_ru_todo_taskbrtt

41 where cq.id = cqw.question_id

42 and cqw.process_ins_id = brtt.cur_process_ins_id

43 and cq.id = t2.id

44 and brtt.trans_actor_id = 'N00251.sz')

45 order by t2.discover_time desc, t2.id) unpaged_

46 WHERE rownum <= 30) unpaged

47 WHERE rn_ > 20;

已选择10行。

已用时间: 00: 00: 00.75

执行计划

----------------------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------

| 0 | SELECT STATEMENT ||1 | | 10 |00:00:00.31 | 2067 | | | |

| 1 | TABLE ACCESS BY INDEX ROWID | CFMS_SYS |1 |1 |1 |00:00:00.01 | 2 | | | |

|* 2 | INDEX UNIQUE SCAN| CFMS_SYS_PK|1 |1 |1 |00:00:00.01 | 1 | | | |

| 3 | TABLE ACCESS BY INDEX ROWID | CFMS_MODULE|1 |1 |0 |00:00:00.01 | 0 | | | |

|* 4 | INDEX UNIQUE SCAN| CFMS_MODUL |1 |1 |0 |00:00:00.01 | 0 | | | |

| 5 | SORT AGGREGATE || 10 |1 | 10 |00:00:00.01 | 3 | | | |

|* 6 | INDEX RANGE SCAN | IND_CR_QUESTION_ID | 10 |3 |0 |00:00:00.01 | 3 | | | |

|* 7 | TABLE ACCESS FULL | CFMS_VERSIONS |1 |1 |0 |00:00:00.01 | 6 | | | |

| 8 | SORT AGGREGATE || 10 |1 | 10 |00:00:00.01 |10 | | | |

|* 9 | HASH JOIN || 10 |5 |0 |00:00:00.01 |10 | 821K| 821K| 176K (0)|

| 10 | TABLE ACCESS BY INDEX ROWID | CFMS_TAG_QUESTION| 10 |5 |0 |00:00:00.01 |10 | | | |

|* 11 | INDEX RANGE SCAN | IND_TQ_QUESTION_ID | 10 |5 |0 |00:00:00.01 |10 | | | |

| 12 | TABLE ACCESS FULL | CFMS_TAG |0 |9 |0 |00:00:00.01 | 0 | | | |

| 13 | MAT_VIEW ACCESS BY INDEX ROWID| V_USER |1 |1 |0 |00:00:00.01 | 0 | | | |

|* 14 | INDEX UNIQUE SCAN| PK_PUB_USER|1 |1 |0 |00:00:00.01 | 0 | | | |

| 15 | SORT AGGREGATE || 10 |1 | 10 |00:00:00.01 |16 | | | |

| 16 | TABLE ACCESS BY INDEX ROWID | CFMS_QUESTION_MODIFY | 10 |1 | 10 |00:00:00.01 |16 | | | |

|* 17 | INDEX RANGE SCAN| IND_QM_QUESTION_ID | 10 |3 | 10 |00:00:00.01 | 8 | | | |

| 18 | SORT AGGREGATE || 10 |1 | 10 |00:00:00.42 | 3840 | | | |

|* 19 | HASH JOIN || 10 |1 | 10 |00:00:00.42 | 3840 | 894K| 894K| 384K (0)|

| 20 | NESTED LOOPS || 10 |1 | 10 |00:00:00.01 |40 | | | |

|* 21 | INDEX UNIQUE SCAN | CFMS_QUESTIONS | 10 |1 | 10 |00:00:00.01 |15 | | | |

| 22 | TABLE ACCESS BY INDEX ROWID| CFMS_QUESTION_WORKFLOW | 10 |1 | 10 |00:00:00.01 |25 | | | |

|* 23 |INDEX RANGE SCAN | IND_QW_QUESTION_ID | 10 |1 | 10 |00:00:00.01 |15 | | | |

|* 24 | TABLE ACCESS FULL | BPMS_RU_TODO_TASK| 10 | 1424 | 43880 |00:00:00.12 | 3800 | | | |

|* 25 | VIEW ||1 |1 | 10 |00:00:00.31 | 2067 | | | |

|* 26 | COUNT STOPKEY ||1 | | 30 |00:00:00.31 | 2067 | | | |

| 27 | VIEW||1 |1 | 30 |00:00:00.31 | 2067 | | | |

|* 28 | SORT ORDER BY STOPKEY||1 |1 | 30 |00:00:00.31 | 2067 | 6144 | 6144 | 6144 (0)|

|* 29 |HASH JOIN RIGHT SEMI||1 |1 | 4370 |00:00:00.30 | 2067 | 1063K| 1063K| 1414K (0)|

| 30 | VIEW | VW_SQ_1 |1 | 1424 | 4379 |00:00:00.21 | 1813 | | | |

| 31 | NESTED LOOPS||1 | 1424 | 4379 |00:00:00.19 | 1813 | | | |

|* 32 | HASH JOIN ||1 | 1424 | 4379 |00:00:00.11 | 440 | 974K| 974K| 1439K (0)|

|* 33 | TABLE ACCESS FULL | BPMS_RU_TODO_TASK|1 | 1424 | 4388 |00:00:00.01 | 380 | | | |

| 34 | TABLE ACCESS FULL | CFMS_QUESTION_WORKFLOW |1 | 1674 | 5217 |00:00:00.01 |60 | | | |

|* 35 | INDEX UNIQUE SCAN| CFMS_QUESTIONS | 4379 |1 | 4379 |00:00:00.04 | 1373 | | | |

|* 36 | TABLE ACCESS FULL | CFMS_QUESTIONS |1 | 3774 | 5179 |00:00:00.02 | 254 | | | |

----------------------------------------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):

---------------------------------------------------

2 - access(“CS”.“SYS_ID”=:B1)

4 - access(“M”.“MODULE_ID”=:B1)

6 - access(“CR”.“QUESTION_ID”=:B1)

7 - filter(“V”.“VERSION_ID”=:B1)

9 - access(“T”.“TAG_ID”=“TQ”.“TAG_ID”)

11 - access(“TQ”.“QUESTION_ID”=:B1)

14 - access(“U”.“USER_ID”=:B1)

17 - access(“M”.“QUESTION_ID”=:B1)

19 - access(“CQW”.“PROCESS_INS_ID”=“BRTT”.“CUR_PROCESS_INS_ID”)

21 - access(“CQ”.“ID”=:B1)

23 - access(“CQW”.“QUESTION_ID”=:B1)

24 - filter(“BRTT”.“TRANS_ACTOR_ID”='N00251.sz')

25 - filter(“RN_”>20)

26 - filter(ROWNUM<=30)

28 - filter(ROWNUM<=30)

29 - access(“ITEM_1”=“T2”.“ID”)

32 - access(“CQW”.“PROCESS_INS_ID”=“BRTT”.“CUR_PROCESS_INS_ID”)

33 - filter(“BRTT”.“TRANS_ACTOR_ID”='N00251.sz')

35 - access(“CQ”.“ID”=“CQW”.“QUESTION_ID”)

36 - filter(“T2”.“STATE”(-1))

篇9：mysql的查询、子查询及连接查询分析

一、mysql查询的五种子句

where(条件查询)、having（筛选）、group by（分组）、order by（排序）、

limit（限制结果数）

1、where常用运算符：

比较运算符

> , < ,= , != （< >）,>= , <=

in(v1,v2..vn)

between v1 and v2 在v1至v2之间（包含v1,v2）

逻辑运算符

not ( ! ) 逻辑非

or ( || ) 逻辑或

and ( && ) 逻辑与

where price>=3000 and price <= 5000 or price >=500 and price <=1000

取500-1000或者3000-5000的值

where price not between 3000 and 5000

不在3000与5000之间的值

模糊查询

like 像

通配符:

% 任意字符

_ 单个字符

where goods_name like '诺基亚%'

where goods_name like '诺基亚N__'

2、group by 分组 www.hanwangtx.com

一般情况下group需与统计函数（聚合函数）一起使用才有意义

如：select goods_id,goods_name,cat_id,max(shop_price) from

goods group by cat_id;

这里取出来的结果中的good_name是错误的！

因为shop_price使用了max函数，那么它是取最大的，而语句中使用了group by 分组，

那么goods_name并没有使用聚合函数，它只是cat_id下的第一个商品，并不会因为shop_price改变

而改变

mysql中的五种统计函数：

（1）max：求最大值

select max(goods_price) from goods

这里会取出最大的价格的值，只有值

#查询每个栏目下价格最高的

select cat_id,max(goods_price) from goos group by cat_id;

#查出价格最高的商品编号

select goods_id,max(goods_price) from goods group by goods_id;

（2）min：求最小值

（3）sum：求总数和

#求商品库存总和

select sum(goods_number) from goods;

（4）avg：求平均值

#求每个栏目的商品平均价格

select cat_id,avg(goods_price) from goods group by cat_id;

（5）count：求总行数

#求每个栏目下商品种类

select cat_id,count(*) from goods group by cat_id;

###要把每个字段名当成变量来理解，它可以进行运算###

例：查询本店每个商品价格比市场价低多少；

select goods_id,goods_name,goods_price-market_price from goods;

查询每个栏目下面积压的货款

select cat_id,sum(goods_price*goods_number) from goods

group by cat_id;

###可以用as来给计算结果取个别名###

select cat_id,sum(goods_price * goods_number) as hk from

goods group by cat_id

不仅列名可以取别名，表单也可以取别名 www.hanwangtx.com

3、having 与where 的异同点

having与where类似，可以筛选数据，where后的表达式怎么写，having后就怎么写

where针对表中的列发挥作用，查询数据

having对查询结果中的列发挥作用，筛选数据

#查询本店商品价格比市场价低多少钱，输出低200元以上的商品

select goods_id,good_name,market_price - shop_price as s from goods having s>200 ;

//这里不能用where因为s是查询结果，而where只能对表中的字段名筛选

如果用where的话则是：

select goods_id,goods_name from goods where market_price - shop_price > 200;

#同时使用where与having

select cat_id,goods_name,market_price - shop_price as s from goods where cat_id = 3 having s > 200;

#查询积压货款超过2万元的栏目，以及该栏目积压的货款

select cat_id,sum(shop_price * goods_number) as t from goods group by cat_id having s > 0

#查询两门及两门以上科目不及格的学生的平均分

思路：

#先计算所有学生的平均分

select name,avg(score) as pj from stu group by name;

#查出所有学生的挂科情况

select name,score<60 from stu;

#这里score<60是判断语句，所以结果为真或假，mysql中真为1假为0

#查出两门及两门以上不及格的学生

select name,sum(score<60) as gk from stu group by name having gk > 1;

#综合结果

select name,sum(score<60) as gk,avg(score) as pj from stu group by name having gk >1;

4、order by

（1） order by price //默认升序排列

（2）order by price desc //降序排列

（3）order by price asc //升序排列，与默认一样

（4）order by rand //随机排列，效率不高

#按栏目号升序排列，每个栏目下的商品价格降序排列

select * from goods where cat_id !=2 order by cat_id,price desc;

5、limit

limit [offset,] N

offset 偏移量，可选，不写则相当于limit 0,N

N 取出条目

#取价格第4-6高的商品

select good_id,goods_name,goods_price from goods order by good_price desc limit 3,3; www.2cto.com

###查询每个栏目下最贵的商品

思路：

#先对每个栏目下的商品价格排序

篇10：迟子建简单介绍

迟子建简单介绍

迟子建，女，中国作家协会第八届主席团成员，黑龙江省作家协会主席，一级作家。1983年开始写作，至今已发表以小说为主的文学作品五百余万字，出版四十余部单行本。主要作品有：长篇小说《伪满洲国》《额尔古纳河右岸》，小说集《逝川》《雾月牛栏》《清水洗尘》，散文随笔集《伤怀之美》《我的世界下雪了》等。出版有《迟子建文集》四卷和三卷的《迟子建作品精华》。

所获荣誉：《雾月牛栏》曾获得第一届鲁迅文学奖、《清水洗尘》获第二届鲁迅文学奖，小说《世界上所有的'夜晚》获第四届鲁迅文学奖()全国优秀中篇小说奖。《额尔古纳河右岸》获第七届茅盾文学奖。澳大利亚悬念句子奖等多种文学奖项，作品有英、法、日、意大利文等海外译本。

迟子建是当今文坛一颗耀眼的明星，她是唯一一位三次获得鲁迅文学奖、两次获得冰心散文奖、一次庄重文文学奖、一次澳大利亚悬念句子文学奖、一次茅盾文学奖的作家。在所有这些奖项中，包括了散文奖、中短篇小说奖、长篇小说奖等。

篇11：宁波医保卡余额查询完整介绍

宁波医保网上查询完整介绍：

宁波市医保个人账户查询

说明：

个人账户查询四种途径：

一是查看最近时间本人医保结算票据，上有账户支出金额及余额;

二是拨打个人账户查询电话0574-8729，输入个人医保号，即可查询账户余额实时信息;

三是登录市劳动保障局网站，通过本人身份证号码查询，余额信息每周更新;

四是持本人身份证或《医保证历本》直接到医保经办机构查询。

[宁波医保卡查询数据由宁波医疗保险管理中心提供]

宁波医保电话查询

宁波医保局医疗保险统一查询电话：(0574-87292000)，内容包括：医疗保险缴费基数、比例查询，医保卡余额查询等。

宁波医保窗口查询

请携带本人有效证件及医保卡号至宁波医保中心办公大厅窗口查询。

宁波市城镇医疗保险管理中心

地址：宁波市解放南路257号

电话：0574-83865203、87327533

个帐科 0574-87307727、83865249、87327533

象山县城镇职工医疗保险管理中心

地址：象山县丹东街道新华路201号

电话：0574-65767702 65767702 申报征缴科 0574-65767708、65767702

宁海县医疗保险管理服务中心

地址：宁海县中山中路87号(建设银行内)

电话：0574-6565、65200159、65200165 申报征缴股 0574-65200156、65200165

余姚市城镇职工医疗保险管理中心

地址：余姚市保庆路128号

电话：0574-62721974、62721974 申报征缴股 0574-62723970、62721974

宁波医保查询网址：www.zjnb.lss.gov.cn

篇12：有关中学生入团时间查询介绍

最新有关中学生入团时间查询介绍：

入团不是强制性的，这只是身为中国人在思想和精神上的一种追求，如果你也有这个追求，一般是初三,但有时也可以是初二。

篇13：入团时间查询方式介绍

查看团员证。

团员证上清楚的写着你的入团时间，只要找到团员证，马上就能查自己的入团时间了。

查询入团申请书。

当你加入共青团的时候，都会填写一份入团申请书，这份申请书上是可以查看自己的入团时间的。

查看档案。

你填写过入团申请书，并且正式成为一名团员，这些都会记录在团委的档案中的，只要找到那些档案，查询一下就知道了。

篇14：武汉医保卡余额查询介绍

武汉医保卡余额查询介绍：

1. 先登陆武汉劳动保障服务网，网址是：www.wh12333.gov.cn/;

2. 点击网页最下面的：“个人查询” ;

3. 输入身份证号，密码是：身份证号第12~17位;

4. 进入后，点“个人查询”―― 可查询缴费情况、个人账户余额情况、历史消费情况。

篇15：SQL查询语句使用简要数据库教程

精华|语句

一、简单查询

简单的Transact-SQL查询只包括选择列表、FROM子句和WHERE子句，它们分别说明所查询列、查询的

表或视图、以及搜索条件等。

例如，下面的语句查询testtable表中姓名为“张三”的nickname字段和email字段。

SELECT nickname,email

FROM testtable

WHERE name='张三'

(一) 选择列表

选择列表(select_list)指出所查询列，它可以是一组列名列表、星号、表达式、变量(包括局部变

量和全局变量)等构成。

1、选择所有列

例如，下面语句显示testtable表中所有列的数据：

SELECT *

FROM testtable

2、选择部分列并指定它们的显示次序

查询结果集合中数据的排列顺序与选择列表中所指定的列名排列顺序相同。

例如：

SELECT nickname,email

FROM testtable

3、更改列标题

在选择列表中，可重新指定列标题。定义格式为：

列标题=列名

列名列标题

如果指定的列标题不是标准的标识符格式时，应使用引号定界符，例如，下列语句使用汉字显示列

标题：

SELECT 昵称=nickname,电子邮件=email

FROM testtable

4、删除重复行

SELECT语句中使用ALL或DISTINCT选项来显示表中符合条件的所有行或删除其中重复的数据行，默认

为ALL。使用DISTINCT选项时，对于所有重复的数据行在SELECT返回的结果集合中只保留一行。

5、限制返回的行数

使用TOP n [PERCENT]选项限制返回的数据行数，TOP n说明返回n行，而TOP n PERCENT时，说明n是

表示一百分数，指定返回的行数等于总行数的百分之几。

例如：

SELECT TOP 2 *

FROM testtable

SELECT TOP 20 PERCENT *

FROM testtable

(二)FROM子句

FROM子句指定SELECT语句查询及与查询相关的表或视图。在FROM子句中最多可指定256个表或视图，

它们之间用逗号分隔。

在FROM子句同时指定多个表或视图时，如果选择列表中存在同名列，这时应使用对象名限定这些列

所属的表或视图。例如在usertable和citytable表中同时存在cityid列，在查询两个表中的cityid时应

使用下面语句格式加以限定：

SELECT username,citytable.cityid

FROM usertable,citytable

WHERE usertable.cityid=citytable.cityid

在FROM子句中可用以下两种格式为表或视图指定别名：

表名 as 别名

表名别名

(二) FROM子句

FROM子句指定SELECT语句查询及与查询相关的表或视图。在FROM子句中最多可指定256个表或视图，

它们之间用逗号分隔。

在FROM子句同时指定多个表或视图时，如果选择列表中存在同名列，这时应使用对象名限定这些列

所属的表或视图。例如在usertable和citytable表中同时存在cityid列，在查询两个表中的cityid时应

使用下面语句格式加以限定：

SELECT username,citytable.cityid

FROM usertable,citytable

WHERE usertable.cityid=citytable.cityid

在FROM子句中可用以下两种格式为表或视图指定别名：

表名 as 别名

表名别名

例如上面语句可用表的别名格式表示为：

SELECT username,b.cityid

FROM usertable a,citytable b

WHERE a.cityid=b.cityid

SELECT不仅能从表或视图中检索数据，它还能够从其它查询语句所返回的结果集合中查询数据。

例如：

SELECT a.au_fname+a.au_lname

FROM authors a,titleauthor ta

(SELECT title_id,title

FROM titles

WHERE ytd_sales>10000

) AS t

WHERE a.au_id=ta.au_id

AND ta.title_id=t.title_id

此例中，将SELECT返回的结果集合给予一别名t，然后再从中检索数据。

(三) 使用WHERE子句设置查询条件

WHERE子句设置查询条件，过滤掉不需要的数据行。例如下面语句查询年龄大于20的数据：

SELECT *

FROM usertable

WHERE age>20

WHERE子句可包括各种条件运算符：

比较运算符(大小比较)：>、>=、=、<、<=、、!>、!<

范围运算符(表达式值是否在指定的范围)：BETWEEN…AND…

NOT BETWEEN…AND…

列表运算符(判断表达式是否为列表中的指定项)：IN (项1,项2……)

NOT IN (项1,项2……)

模式匹配符(判断值是否与指定的字符通配格式相符):LIKE、NOT LIKE

空值判断符(判断表达式是否为空)：IS NULL、NOT IS NULL

逻辑运算符(用于多条件的逻辑连接)：NOT、AND、OR

1、范围运算符例：age BETWEEN 10 AND 30相当于age>=10 AND age<=30

2、列表运算符例：country IN ('Germany','China')

3、模式匹配符例：常用于模糊查找，它判断列值是否与指定的字符串格式相匹配。可用于char、

varchar、text、ntext、datetime和smalldatetime等类型查询。

可使用以下通配字符：

百分号%：可匹配任意类型和长度的字符，如果是中文，请使用两个百分号即%%。

下划线_：匹配单个任意字符，它常用来限制表达式的字符长度。

方括号[]：指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。

[^]：其取值也[] 相同，但它要求所匹配对象为指定字符以外的任一个字符。

例如：

限制以Publishing结尾，使用LIKE '%Publishing'

限制以A开头：LIKE '[A]%'

限制以A开头外：LIKE '[^A]%'

4、空值判断符例WHERE age IS NULL

5、逻辑运算符：优先级为NOT、AND、OR

(四)查询结果排序

使用ORDER BY子句对查询返回的结果按一列或多列排序，

ORDER BY子句的语法格式为：

ORDER BY {column_name [ASC|DESC]} [,…n]

其中ASC表示升序，为默认值，DESC为降序。ORDER BY不能按ntext、text和image数据类型进行排

序。

例如：

SELECT *

FROM usertable

ORDER BY age desc,userid ASC

另外，可以根据表达式进行排序。

二、联合查询

UNION运算符可以将两个或两个以上上SELECT语句的查询结果集合合并成一个结果集合显示，即执行联

合查询。UNION的语法格式为：

select_statement

UNION [ALL] selectstatement

[UNION [ALL] selectstatement][…n]

其中selectstatement为待联合的SELECT查询语句。

ALL选项表示将所有行合并到结果集合中。不指定该项时，被联合查询结果集合中的重复行将只保留一

行。

联合查询时，查询结果的列标题为第一个查询语句的列标题。因此，要定义列标题必须在第一个查询语

句中定义。要对联合查询结果排序时，也必须使用第一查询语句中的列名、列标题或者列序号。

在使用UNION 运算符时，应保证每个联合查询语句的选择列表中有相同数量的表达式，并且每个查询选

择表达式应具有相同的数据类型，或是可以自动将它们转换为相同的数据类型。在自动转换时，对于数值类

型，系统将低精度的数据类型转换为高精度的数据类型。

在包括多个查询的UNION语句中，其执行顺序是自左至右，使用括号可以改变这一执行顺序。例如：

查询1 UNION (查询2 UNION 查询3)

三、连接查询

通过连接运算符可以实现多个表查询。连接是关系数据库模型的主要特点，也是它区别于其它类型

数据库管理系统的一个标志。

在关系数据库管理系统中，表建立时各数据之间的关系不必确定，常把一个实体的所有信息存放在

一个表中。当检索数据时，通过连接操作查询出存放在多个表中的不同实体的信息。连接操作给用户带

来很大的灵活性，他们可以在任何时候增加新的数据类型。为不同实体创建新的表，尔后通过连接进行

查询。

连接可以在SELECT 语句的FROM子句或WHERE子句中建立，似是而非在FROM子句中指出连接时有助于

将连接操作与WHERE子句中的搜索条件区分开来。所以，在Transact-SQL中推荐使用这种方法。

SQL-92标准所定义的FROM子句的连接语法格式为：

FROM join_table join_type join_table

[ON (join_condition)]

其中join_table指出参与连接操作的表名，连接可以对同一个表操作，也可以对多表操作，对同一

个表操作的连接又称做自连接。

join_type 指出连接类型，可分为三种：内连接、外连接和交叉连接。内连接(INNER JOIN)使用比

较运算符进行表间某(些)列数据的比较操作，并列出这些表中与连接条件相匹配的数据行。根据所使用

的比较方式不同，内连接又分为等值连接、自然连接和不等连接三种。

外连接分为左外连接(LEFT OUTER JOIN或LEFT JOIN)、右外连接(RIGHT OUTER JOIN或RIGHT JOIN)

和全外连接(FULL OUTER JOIN或FULL JOIN)三种。与内连接不同的是，外连接不只列出与连接条件相匹

配的行，而是列出左表(左外连接时)、右表(右外连接时)或两个表(全外连接时)中所有符合搜索条件的

数据行。

交叉连接(CROSS JOIN)没有WHERE 子句，它返回连接表中所有数据行的笛卡尔积，其结果集合中的

数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

连接操作中的ON (join_condition) 子句指出连接条件，它由被连接表中的列和比较运算符、逻辑

运算符等构成。

无论哪种连接都不能对text、ntext和image数据类型列进行直接连接，但可以对这三种列进行间接

连接。例如：

SELECT p1.pub_id,p2.pub_id,p1.pr_info

FROM pub_info AS p1 INNER JOIN pub_info AS p2

ON DATALENGTH(p1.pr_info)=DATALENGTH(p2.pr_info)

(一)内连接

内连接查询操作列出与连接条件匹配的数据行，它使用比较运算符比较被连接列的列值。内连接分

三种：

1、等值连接：在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接

表中的所有列，包括其中的重复列。

2、不等连接：在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些

运算符包括>、>=、<=、<、!>、!<和>。

3、自然连接：在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询

结果集合中所包括的列，并删除连接表中的重复列。

例，下面使用等值连接列出authors和publishers表中位于同一城市的作者和出版社：

SELECT *

FROM authors AS a INNER JOIN publishers AS p

ON a.city=p.city

又如使用自然连接，在选择列表中删除authors 和publishers 表中重复列(city和state)：

SELECT a.*,p.pub_id,p.pub_name,p.country

FROM authors AS a INNER JOIN publishers AS p

ON a.city=p.city

(二)外连接

内连接时，返回查询结果集合中的仅是符合查询条件( WHERE 搜索条件或 HAVING 条件)和连接条件

的行。而采用外连接时，它返回到查询结果集合中的不仅包含符合连接条件的行，而且还包括左表(左外

连接时)、右表(右外连接时)或两个边接表(全外连接)中的所有数据行。

如下面使用左外连接将论坛内容和作者信息连接起来：

SELECT a.*,b.* FROM luntan LEFT JOIN usertable as b

ON a.username=b.username

下面使用全外连接将city表中的所有作者以及user表中的所有作者，以及他们所在的城市：

SELECT a.*,b.*

FROM city as a FULL OUTER JOIN user as b

ON a.username=b.username

(三)交叉连接

交叉连接不带WHERE 子句，它返回被连接的两个表所有数据行的笛卡尔积，返回到结果集合中的数

据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

例，titles表中有6类图书，而publishers表中有8家出版社，则下列交叉连接检索到的记录数将等

于6*8=48行。

SELECT type,pub_name

FROM titles CROSS JOIN publishers

ORDER BY type

篇16：SQL查询语句使用数据库教程

语句

作者：任我行一、简单查询

简单的Transact-SQL查询只包括选择列表、FROM子句和WHERE子句，它们分别说明所查询列、查询的

表或视图、以及搜索条件等。

例如，下面的语句查询testtable表中姓名为“张三”的nickname字段和email字段。

SELECT nickname,email

FROM testtable

WHERE name='张三'

(一)选择列表

选择列表(select_list)指出所查询列，它可以是一组列名列表、星号、表达式、变量(包括局部变

量和全局变量)等构成。

1、选择所有列

例如，下面语句显示testtable表中所有列的数据：

SELECT *

FROM testtable

2、选择部分列并指定它们的显示次序

查询结果集合中数据的排列顺序与选择列表中所指定的列名排列顺序相同。

例如：

SELECT nickname,email

FROM testtable

3、更改列标题

在选择列表中，可重新指定列标题。定义格式为：

列标题=列名

列名列标题

如果指定的列标题不是标准的标识符格式时，应使用引号定界符，例如，下列语句使用汉字显示列

标题：

SELECT 昵称=nickname,电子邮件=email

FROM testtable

4、删除重复行

SELECT语句中使用ALL或DISTINCT选项来显示表中符合条件的所有行或删除其中重复的数据行，默认

为ALL。使用DISTINCT选项时，对于所有重复的数据行在SELECT返回的结果集合中只保留一行。

5、限制返回的行数

使用TOP n [PERCENT]选项限制返回的数据行数，TOP n说明返回n行，而TOP n PERCENT时，说明n是

表示一百分数，指定返回的行数等于总行数的百分之几。

例如：

SELECT TOP 2 *

FROM testtable

SELECT TOP 20 PERCENT *

FROM testtable

(二)FROM子句

FROM子句指定SELECT语句查询及与查询相关的表或视图。在FROM子句中最多可指定256个表或视图，

它们之间用逗号分隔。

在FROM子句同时指定多个表或视图时，如果选择列表中存在同名列，这时应使用对象名限定这些列

所属的表或视图。例如在usertable和citytable表中同时存在cityid列，在查询两个表中的cityid时应

使用下面语句格式加以限定：

SELECT username,citytable.cityid

FROM usertable,citytable

WHERE usertable.cityid=citytable.cityid

在FROM子句中可用以下两种格式为表或视图指定别名：

表名 as 别名

表名别名

例如上面语句可用表的别名格式表示为：

SELECT username,b.cityid

FROM usertable a,citytable b

WHERE a.cityid=b.cityid

SELECT不仅能从表或视图中检索数据，它还能够从其它查询语句所返回的结果集合中查询数据。

例如：

SELECT a.au_fname+a.au_lname

FROM authors a,titleauthor ta

(SELECT title_id,title

FROM titles

WHERE ytd_sales>10000

) AS t

WHERE a.au_id=ta.au_id

AND ta.title_id=t.title_id

此例中，将SELECT返回的结果集合给予一别名t，然后再从中检索数据。

(三)使用WHERE子句设置查询条件

WHERE子句设置查询条件，过滤掉不需要的数据行。例如下面语句查询年龄大于20的数据：

SELECT *

FROM usertable

WHERE age>20

WHERE子句可包括各种条件运算符：

比较运算符(大小比较)：>、>=、=、<、<=、、!>、!<

范围运算符(表达式值是否在指定的范围)：BETWEEN…AND…

NOT BETWEEN…AND…

列表运算符(判断表达式是否为列表中的指定项)：IN (项1,项2……)

NOT IN (项1,项2……)

模式匹配符(判断值是否与指定的字符通配格式相符):LIKE、NOT LIKE

空值判断符(判断表达式是否为空)：IS NULL、NOT IS NULL

逻辑运算符(用于多条件的逻辑连接)：NOT、AND、OR

1、范围运算符例：age BETWEEN 10 AND 30相当于age>=10 AND age<=30

2、列表运算符例：country IN ('Germany','China')

3、模式匹配符例：常用于模糊查找，它判断列值是否与指定的字符串格式相匹配。可用于char、

varchar、text、ntext、datetime和smalldatetime等类型查询。

可使用以下通配字符：

百分号%：可匹配任意类型和长度的字符，如果是中文，请使用两个百分号即%%。

下划线_：匹配单个任意字符，它常用来限制表达式的字符长度。

方括号[]：指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。

[^]：其取值也[] 相同，但它要求所匹配对象为指定字符以外的任一个字符。

例如：

限制以Publishing结尾，使用LIKE '%Publishing'

限制以A开头：LIKE '[A]%'

限制以A开头外：LIKE '[^A]%'

4、空值判断符例WHERE age IS NULL

5、逻辑运算符：优先级为NOT、AND、OR

(四)查询结果排序

使用ORDER BY子句对查询返回的结果按一列或多列排序。ORDER BY子句的语法格式为：

ORDER BY {column_name [ASC|DESC]} [,…n]

其中ASC表示升序，为默认值，DESC为降序。ORDER BY不能按ntext、text和image数据类型进行排

序。

例如：

SELECT *

FROM usertable

ORDER BY age desc,userid ASC

另外，可以根据表达式进行排序，

二、联合查询

UNION运算符可以将两个或两个以上上SELECT语句的查询结果集合合并成一个结果集合显示，即执行联

合查询。UNION的语法格式为：

select_statement

UNION [ALL] selectstatement

[UNION [ALL] selectstatement][…n]

其中selectstatement为待联合的SELECT查询语句。

ALL选项表示将所有行合并到结果集合中。不指定该项时，被联合查询结果集合中的重复行将只保留一

行。

联合查询时，查询结果的列标题为第一个查询语句的列标题。因此，要定义列标题必须在第一个查询语

句中定义。要对联合查询结果排序时，也必须使用第一查询语句中的列名、列标题或者列序号。

在使用UNION 运算符时，应保证每个联合查询语句的选择列表中有相同数量的表达式，并且每个查询选

择表达式应具有相同的数据类型，或是可以自动将它们转换为相同的数据类型。在自动转换时，对于数值类

型，系统将低精度的数据类型转换为高精度的数据类型。

在包括多个查询的UNION语句中，其执行顺序是自左至右，使用括号可以改变这一执行顺序。例如：

查询1 UNION (查询2 UNION 查询3)

三、连接查询

通过连接运算符可以实现多个表查询。连接是关系数据库模型的主要特点，也是它区别于其它类型

数据库管理系统的一个标志。

在关系数据库管理系统中，表建立时各数据之间的关系不必确定，常把一个实体的所有信息存放在

一个表中。当检索数据时，通过连接操作查询出存放在多个表中的不同实体的信息。连接操作给用户带

来很大的灵活性，他们可以在任何时候增加新的数据类型。为不同实体创建新的表，尔后通过连接进行

查询。

连接可以在SELECT 语句的FROM子句或WHERE子句中建立，似是而非在FROM子句中指出连接时有助于

将连接操作与WHERE子句中的搜索条件区分开来。所以，在Transact-SQL中推荐使用这种方法。

SQL-92标准所定义的FROM子句的连接语法格式为：

FROM join_table join_type join_table

[ON (join_condition)]

其中join_table指出参与连接操作的表名，连接可以对同一个表操作，也可以对多表操作，对同一

个表操作的连接又称做自连接。

join_type 指出连接类型，可分为三种：内连接、外连接和交叉连接。内连接(INNER JOIN)使用比

较运算符进行表间某(些)列数据的比较操作，并列出这些表中与连接条件相匹配的数据行。根据所使用

的比较方式不同，内连接又分为等值连接、自然连接和不等连接三种。

外连接分为左外连接(LEFT OUTER JOIN或LEFT JOIN)、右外连接(RIGHT OUTER JOIN或RIGHT JOIN)

和全外连接(FULL OUTER JOIN或FULL JOIN)三种。与内连接不同的是，外连接不只列出与连接条件相匹

配的行，而是列出左表(左外连接时)、右表(右外连接时)或两个表(全外连接时)中所有符合搜索条件的

数据行。

交叉连接(CROSS JOIN)没有WHERE 子句，它返回连接表中所有数据行的笛卡尔积，其结果集合中的

数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

连接操作中的ON (join_condition) 子句指出连接条件，它由被连接表中的列和比较运算符、逻辑

运算符等构成。

无论哪种连接都不能对text、ntext和image数据类型列进行直接连接，但可以对这三种列进行间接

连接。例如：

SELECT p1.pub_id,p2.pub_id,p1.pr_info

FROM pub_info AS p1 INNER JOIN pub_info AS p2

ON DATALENGTH(p1.pr_info)=DATALENGTH(p2.pr_info)

(一)内连接

内连接查询操作列出与连接条件匹配的数据行，它使用比较运算符比较被连接列的列值。内连接分

三种：

1、等值连接：在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接

表中的所有列，包括其中的重复列。

2、不等连接：在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些

运算符包括>、>=、<=、<、!>、!<和>。

3、自然连接：在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询

结果集合中所包括的列，并删除连接表中的重复列。

例，下面使用等值连接列出authors和publishers表中位于同一城市的作者和出版社：

SELECT *

FROM authors AS a INNER JOIN publishers AS p

ON a.city=p.city

又如使用自然连接，在选择列表中删除authors 和publishers 表中重复列(city和state)：

SELECT a.*,p.pub_id,p.pub_name,p.country

FROM authors AS a INNER JOIN publishers AS p

ON a.city=p.city

(二)外连接

内连接时，返回查询结果集合中的仅是符合查询条件( WHERE 搜索条件或 HAVING 条件)和连接条件

的行。而采用外连接时，它返回到查询结果集合中的不仅包含符合连接条件的行，而且还包括左表(左外

连接时)、右表(右外连接时)或两个边接表(全外连接)中的所有数据行。

如下面使用左外连接将论坛内容和作者信息连接起来：

SELECT a.*,b.* FROM luntan LEFT JOIN usertable as b

ON a.username=b.username

下面使用全外连接将city表中的所有作者以及user表中的所有作者，以及他们所在的城市：

SELECT a.*,b.*

FROM city as a FULL OUTER JOIN user as b

ON a.username=b.username

(三)交叉连接

交叉连接不带WHERE 子句，它返回被连接的两个表所有数据行的笛卡尔积，返回到结果集合中的数

据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

例，titles表中有6类图书，而publishers表中有8家出版社，则下列交叉连接检索到的记录数将等

于6*8=48行。

SELECT type,pub_name

FROM titles CROSS JOIN publishers

ORDER BY type

篇17：USBDeview工具使用介绍

有些时候我们想了解U盘的一些信息，比如设备添加的日期以及最后连接的日期等，现在就为您介绍一款工具——USBDeview，

USBDeview是一款小巧免费的USB设备检测和管理工具，功能颇为强大，可以列出当前连接到你的计算机上或者曾经连接到你的计算机上的所有USB设备以及相关信息，并能进行相应的管理操作，

根据列出的设备的名称和描述，该软件显示了串口号(如果提供)，设备添加的日期以及最后连接的日期、VendorID以及其它信息，并能够导出该列表为Text/HTML或者XML格式;可以根据需求选择禁用或者卸载列表中任何设备，USBDeview还可以被用于从一台远程计算机(需要访问权)通过命令行收集USB设备等。

当然也能够利用USBDeview实现禁止u盘，如果你不希望自己的电脑识别和支持别人的移动设备，那么可以通过下面的小方法实现：插入自己的U盘可以看到有颜色表示，连接状态里也为yes，您记下自己的U盘名称或型号描述，将其它人的U盘选定，按一下F6键或点击禁用设备按钮，将它们全部禁用。这样他人的U盘再插到自己的电脑上就不会被识别，也无法使用了。

篇18：简单介绍pythonnmap 模块的使用

python-nmap是python的一个模块库，使用这个模块可以让python很方便的操作nmap扫描器来工作，它可以帮助管理员完成自动扫描任务和生成报告的工具，它还支持nmap的脚步输出，最新的版本是python-nmap-0.2.4.tar.gz,

下载地址是：xael.org/norman/python/python-nmap/python-nmap-0.2.4.tar.gz

不过这个版本是适合python3.*来使用的，如果你的python版本还是2.*的话，还是使用这个版本，python- nmap.0.1.4.tar.gz, 下载链接是xael.org/norman/python/python-nmap/python-nmap-0.1.4.tar.gz

安装还是很简单的，解压缩，运行setup.py install之后，就搞定了。

下面贴出自带的example.py的源码：

#!/usr/bin/env python

# -*- coding: latin-1 -*-

import sys

import nmap # import nmap.py module

try:

nm = nmap.PortScanner # instantiate nmap.PortScanner object

except nmap.PortScannerError:

print(‘Nmap not found’, sys.exc_info()[0])

sys.exit(0)

except:

print(“Unexpected error:”, sys.exc_info()[0])

sys.exit(0)

nm.scan(‘127.0.0.1′, ’22-443′) # scan host 127.0.0.1, ports from 22 to 443

nm.command_line() # get command line used for the scan : nmap -oX – -p 22-443 127.0.0.1

nm.scaninfo() # get nmap scan informations {‘tcp': {‘services': ’22-443′, ‘method': ‘connect’}}

nm.all_hosts() # get all hosts that were scanned

nm[‘127.0.0.1′].hostname() # get hostname for host 127.0.0.1

nm[‘127.0.0.1′].state() # get state of host 127.0.0.1 (up|down|unknown|skipped)

nm[‘127.0.0.1′].all_protocols() # get all scanned protocols [‘tcp’, ‘udp’] in (ip|tcp|udp|sctp)

nm[‘127.0.0.1′][‘tcp’].keys() # get all ports for tcp protocol

nm[‘127.0.0.1′].all_tcp() # get all ports for tcp protocol (sorted version)

nm[‘127.0.0.1′].all_udp() # get all ports for udp protocol (sorted version)

nm[‘127.0.0.1′].all_ip() # get all ports for ip protocol (sorted version)

nm[‘127.0.0.1′].all_sctp() # get all ports for sctp protocol (sorted version)

nm[‘127.0.0.1′].has_tcp(22) # is there any information for port 22/tcp on host 127.0.0.1

nm[‘127.0.0.1′][‘tcp’][22] # get infos about port 22 in tcp on host 127.0.0.1

nm[‘127.0.0.1′].tcp(22) # get infos about port 22 in tcp on host 127.0.0.1

nm[‘127.0.0.1′][‘tcp’][22][‘state’] # get state of port 22/tcp on host 127.0.0.1 (open

# a more usefull example :

for host in nm.all_hosts():

print(‘—————————————————-‘)

print(‘Host : %s (%s)’ % (host, nm[host].hostname()))

print(‘State : %s’ % nm[host].state())

for proto in nm[host].all_protocols():

print(‘———-‘)

print(‘Protocol : %s’ % proto)

lport = nm[host][proto].keys()

lport.sort()

for port in lport:

print(‘port : %

ststate : %s’ % (port, nm[host][proto][port][‘state’]))

print(‘—————————————————-‘)

# If you want to do a pingsweep on network 192.168.1.0/24:

nm.scan(hosts=’192.168.1.0/24′, arguments=’-n -sP -PE -PA21,23,80,3389′)

hosts_list = [(x, nm[x][‘status’][‘state’]) for x in nm.all_hosts()]

for host, status in hosts_list:

print(‘{0}:{1}’.format(host, status))

print ‘—————————————————-‘

# Asynchronous usage of PortScannerAsync

nma = nmap.PortScannerAsync()

def callback_result(host, scan_result):

print ‘——————’

print host, scan_result

nma.scan(hosts=’192.168.1.0/30′, arguments=’-sP’, callback=callback_result)

while nma.still_scanning():

print(“Waiting …”)

nma.wait(2) # you can do whatever you want but I choose to wait after the end of the scan

下面看下运行的效果：

[root@centos6 nmap]# python example.py

—————————————————-

Host : 127.0.0.1 (localhost)

State : up

———-

Protocol : tcp

port : 22 state : open

port : 25 state : open

port : 80 state : open

—————————————————-

192.168.1.0:down

192.168.1.1:down

192.168.1.10:down

192.168.1.100:down

，

。。

192.168.1.159:down

192.168.1.16:down

192.168.1.160:down

192.168.1.161:down

192.168.1.162:down

192.168.1.163:down

192.168.1.164:down

192.168.1.165:down

192.168.1.166:down

192.168.1.167:down

192.168.1.168:down

192.168.1.169:down

。。。

192.168.1.97:down

192.168.1.98:down

192.168.1.99:down

—————————————————-

Waiting …

——————

192.168.1.0 {‘nmap': {‘scanstats': {‘uphosts': u’0′, ‘timestr': u’Mon Nov 14 17:25:27 ′, ‘downhosts': u’1′, ‘totalhosts': u’1′, ‘elapsed': u’1.24′}, ‘scaninfo': {}, ‘command_line': u’nmap -oX – -sP 192.168.1.0′}, ‘scan': {u’192.168.1.0′: {‘status': {‘state': u’down’, ‘reason': u’host-unreach’}, ‘hostname': ”}}}

Waiting …

——————

192.168.1.1 {‘nmap': {‘scanstats': {‘uphosts': u’0′, ‘timestr': u’Mon Nov 14 17:25:28 2011′, ‘downhosts': u’1′, ‘totalhosts': u’1′, ‘elapsed': u’1.23′}, ‘scaninfo': {}, ‘command_line': u’nmap -oX – -sP 192.168.1.1′}, ‘scan': {u’192.168.1.1′: {‘status': {‘state': u’down’, ‘reason': u’host-unreach’}, ‘hostname': ”}}}

Waiting …

——————

192.168.1.2 {‘nmap': {‘scanstats': {‘uphosts': u’0′, ‘timestr': u’Mon Nov 14 17:25:29 2011′, ‘downhosts': u’1′, ‘totalhosts': u’1′, ‘elapsed': u’1.23′}, ‘scaninfo': {}, ‘command_line': u’nmap -oX – -sP 192.168.1.2′}, ‘scan': {u’192.168.1.2′: {‘status': {‘state': u’down’, ‘reason': u’host-unreach’}, ‘hostname': ”}}}

——————

192.168.1.3 {‘nmap': {‘scanstats': {‘uphosts': u’0′, ‘timestr': u’Mon Nov 14 17:25:31 2011′, ‘downhosts': u’1′, ‘totalhosts': u’1′, ‘elapsed': u’1.23′}, ‘scaninfo': {}, ‘command_line': u’nmap -oX – -sP 192.168.1.3′}, ‘scan': {u’192.168.1.3′: {‘status': {‘state': u’down’, ‘reason': u’host-unreach’}, ‘hostname': ”}}}

其他功能大家可以自己实践，安装这个模块，首先系统必须要安装好nmap这个软件是必须条件。。。