2008年3月9日
1、test.html 测试页
<html>
<head>
<title>测试页面</title>
<style>
.list {
border-top:1 solid #8A2BE2;
border-left:1 solid #8A2BE2;
border-right:1 solid #8A2BE2;
}
.list td {
border-bottom: 1 solid #8A2BE2;
}
</style>
<script>
function $(el) {
return document.getElementById(el);
}
function showWin(param) {
window.showModalDialog("dailog.htm", param, "dialogWidth:" +param.width +"px;dialogHeight:"+param.height+"px;center:yes;help:no;scroll:no;status:no;resizable:no");
}
function TB(tbid) {
this.tb = typeof(tbid) == "string"? $(tbid): tbid;
this.getValue = function(rowIndex, cellIndex){
var trs = this.tb.rows[rowIndex];
var _td = trs.cells[cellIndex];
return _td.innerText;
}
this.setValue = function(rowIndex, cellIndex, value) {
var _tr = this.tb.rows[rowIndex];
var _td = _tr.cells[cellIndex];
_td.innerText = value;
}
/********获取行索引********/
this.findRowIndex = function(eventSrc) {
var _tr = eventSrc; //eventSrc事件源,必须在TD里获事件源是TD或TR本身
while(_tr.tagName != "TR") {
_tr = _tr.parentNode;
}
var trs = this.tb.rows;
for(var i = 0; i < trs.length; i++){
if(_tr == trs[i]) return i;
}
}
}
function edit() {
var tb = new TB("data");
rIndex = tb.findRowIndex(event.srcElement);
$("updateRowIndex").value = rIndex;
$("userName").value = tb.getValue(rIndex, 1); //获得姓名
$("sex").value = tb.getValue(rIndex, 2); //获得性别
$("age").value = tb.getValue(rIndex, 3); //获得年龄
showWin({title:"修改用户信息", width:390, height:230, _div:"openWin",parent:window});
}
function saveAndUpdateView(){
var updateRowIndex = $("updateRowIndex").value;
var tb = new TB($f("data")); //$f()在dailog.html定义,获到的table是父窗口中的table
tb.setValue(updateRowIndex, 1, $("userName").value);
tb.setValue(updateRowIndex, 2, $("sex").value);
tb.setValue(updateRowIndex, 3, $("age").value);
close();
}
</script>
</head>
<body>
<p style="margin-top:60px">
<center>
<table id="data" class="list" width="460px">
<tr>
<td>编号</td>
<td>用户名</td>
<td>性别</td>
<td>年龄</td>
<td>操作</td>
</tr>
<tr>
<td>1</td>
<td>李永胜</td>
<td>男</td>
<td>27</td>
<td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
</tr>
<tr>
<td>2</td>
<td>林兄</td>
<td>男</td>
<td>27</td>
<td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
</tr>
<tr>
<td>3</td>
<td>叶兄</td>
<td>男</td>
<td>23</td>
<td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
</tr>
</table>
</center>
</p>
<!---弹出窗口显示的内容---->
<div id="openWin" style="display:none;">
<form>
<fieldSet>
<legend>修改用户</legend>
<table>
<tr>
<td>用户名</td><td><input type="text" id="userName"/></td>
</tr>
<tr>
<td>性别</td><td><input type="text" id="sex"/></td>
</tr>
<tr>
<td>年龄</td><td><input type="text" id="age"/></td>
</tr>
</table>
</fieldSet>
<input type="hidden" id="updateRowIndex"/>
</form>
<span style="background:#FAEBD7;cursor:hand" onclick="saveAndUpdateView();"> 修改 </span>
</div>
</body>
</html>
2、dailog.html 窗口原型
<html>
<head>
<script>
var param = window.dialogArguments; //传过来的模式对话框窗口参数
document.title = param.title; //窗口标题,必须在窗口创建前实现s
/********将父窗口的js加载进来********/
var scripts = param.parent.document.scripts;
var _head = document.getElementsByTagName("head")[0];
for(var n = 0; n < scripts.length; n++) {
if(scripts[n].src) {
var _script = newEl("script");
_script.src = scripts[n].src;
bind(_head, _script);
}else{//加载直接在html文档中写的script
var _script = newEl("script");
_script.text = scripts[n].text;
bind(_head, _script);
}
}
/*******根据ID获得父窗口的元素*********/
function $f(el) {
return param.parent.document.getElementById(el);
}
/***********创建一个HTML元素*******/
function newEl(tagName) {
return document.createElement(tagName);
}
/***********追加元素***************/
function bind(ower, child) {
ower.appendChild(child);
}
/*******在浏览器完成对象的装载后立即触发*********/
window.onload = function() {
var winDiv;
if(typeof(param._div) == "string") {
winDiv = param.parent.document.getElementById(param._div); //父窗口window对象,因为param._div对象在父窗口
}else{//直接传对象过来
winDiv = param._div;
}
$("mainDiv").innerHTML = winDiv.innerHTML; //将DIV内容在弹出窗口中渲染
}
</script>
</head>
<body>
<center>
<div id="mainDiv" style="margin-top:20px;width:90%"></div>
</center>
</body>
</html>
posted @
2008-05-05 10:43 虎啸龙吟 阅读(1896) |
评论 (0) |
编辑 收藏
基本方法：
基本的方法，网上到处都是，在 java 中就是在 web.xml 注册一个 Listener ，如下：
<listener>
<listener-class>xp.web.SessionCounter</listener-class>
</listener>
SessionCounter.java 实现 javax.servlet.http.HttpSessionListener 接口，分别在 sessionCreated 方法和 sessionDestroyed 方法中处理 session 数目。
这样的方法有一定的问题：
1 、对于真正从网页访问的和搜索引擎的 spider 无法区分。
2 、当 Tomcat 重启时，加载了上次持久化的 session 时，无法准确计算在线数。
第二个问题我们可以不予考虑，这是 tomcat 容器实现不标准的问题，我们要解决的是的第一个问题，如何知道你的访问的是真实的。
用 js 绕过搜索引擎 ：
做过 pv 统计的都知道，可以用 script 的方式得到你真实的 pageView 数目，我们现在要做的就是这样的一件事情，我们在所有的页面都加入一段话：
<script type="text/javascript">
document.write ("<iframe src='/sessionCountServlet' width=0 height=0 frameborder=no border=0 MARGINWIDTH=0 MARGINHEIGHT=0 SCROLLING=no></iframe>");
</script>
然后我们写上一个 servlet 来记录这些真正的访问者。
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SessionCounterServlet extends HttpServlet {
public SessionCounterServlet() {
super();
}
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws IOException,
ServletException {
process(request, response);
}
public void doPost(HttpServletRequest request,
HttpServletResponse response) throws IOException,
ServletException {
process(request, response);
}
public void process(HttpServletRequest request,
HttpServletResponse response) throws IOException,
ServletException {
SessionCounter.put(request.getSession().getId());
}
}
我们可以看到这个 servlet 只是做了一件事情，在 process 里面做了 SessionCounter.put(request.getSession().getId()); 这个动作。
我们来看看我们的 SessionCounter 做了些什么：
import javax.servlet.http.*;
import java.util.Hashtable;
public class SessionCounter implements HttpSessionListener {
public SessionCounter() {
}
public static Hashtable m_real = new Hashtable();
private static long count = 0;
public void sessionCreated(HttpSessionEvent e) {
count++;
}
public void sessionDestroyed(HttpSessionEvent e) {
if (count > 0) {
count--;
}
m_real.remove(e.getSession().getId());
}
public static long getSessionCount() {
return count;
}
public static void put(String sessionId){
m_real.put(sessionId,"1");
}
public static int getRealCount(){
return m_real.size();
}
}
我们记录了一个静态的 hash 表来记录激活状态的 sessionid ，并在 session 销毁的时候将这个 sessionid 置为空。
怎么把 servlet 配置到 web 应用中我就不罗唆了。
posted @
2008-04-21 11:37 虎啸龙吟 阅读(289) |
评论 (0) |
编辑 收藏这部分的内容基本与Hibernate一致.JPA同样支持3种类型的继承形式:
1.Single Table Strategy ,单表策略,一张表包含基类与子类的所有数据,很多情况下都是采用这样的冗余设计,通过一个discriminator来区分
2.Table Per Class Strategy ,每个子类对应一张表,每张表都拥有基类的属性
3.Join Strategy ,仍然是每个子类对应一张表，但此表中不包含基类的属性,仅仅是此子类的扩展属性,共享基类的属性
以一个例子来说明3种情况:
一.单表策略
比如Pet作为基类,Cat和Dog继承此类并拥有自己的扩展属性,如:
package com.denny_blue.ejb3.inheritance;
import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "animal_type", discriminatorType = DiscriminatorType.STRING)
public class Pet implements Serializable {
private int id;
private String name;
private double weight;
public Pet() {
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
}
Pet类值的注意的就是通过@Inheritance(strategy = InheritanceType.SINGLE_TABLE)确定采用单表策略,通过@DiscriminatorColumn确定了标志值的字段和类型，我想熟悉hibernate的朋友对这些都应该很熟悉.然后是两个子类:
//Cat.java
package com.denny_blue.ejb3.inheritance;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("cat")
public class Cat extends Pet {
private String HairBall;
public String getHairBall() {
return HairBall;
}
public void setHairBall(String hairBall) {
HairBall = hairBall;
}
}
//Dog.java
package com.denny_blue.ejb3.inheritance;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("dog")
public class Dog extends Pet {
private String trick;
public String getTrick() {
return trick;
}
public void setTrick(String trick) {
this.trick = trick;
}
}
两个子类最值的关注的就是@DiscriminatorValue注释,比如Cat的此值为cat,意味着当Cat类型的Entity存入数据库时,JPA将自动把cat的值赋给animal_type字段,Dog的值则为dog,由此就可以在同一张表中区分开两个不同的子类.
二.Table per Class
采用Table Per Class策略的话，每个子类都将单独建表，并且都独立拥有基类中的所有属性,互相之间不共享,在我们的例子中所要进行的修改很小,像这样:
//基类
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Pet implements Serializable {
private int id;
private String name;
private double weight;
........
//子类:不需要任何设置
@Entity
public class Dog extends Pet {
private String trick;
.......
.......
三.Join策略
每个子类同样独立建表,基类也独立建表，只不过所有的子类的表中只有扩展属性,他们共享基类的表,在我们的例子中修改下即可:
//基类
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pet implements Serializable {
private int id;
private String name;
private double weight;
........
//子类
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Dog extends Pet {
private String trick;
.......
.......
这部分的内容实在没什么新意,与hibernate完全一致.JAVA EE5向spring和hibernate借鉴了太多东西.
{}
posted @
2008-04-21 11:20 虎啸龙吟 阅读(301) |
评论 (0) |
编辑 收藏Oracle sql 性能优化调整
1. 选用适合的ORACLE优化器
ORACLE的优化器共有3种：
a. RULE (基于规则)
b. COST (基于成本)
c. CHOOSE (选择性)
设置缺省的优化器，可以通过对init.ora文件中OPTIMIZER_MODE参数的各种声明，如RULE，COST，CHOOSE，ALL_ROWS，FIRST_ROWS . 你当然也在SQL句级或是会话(session)级对其进行覆盖。
为了使用基于成本的优化器(CBO， Cost-Based Optimizer) ， 你必须经常运行analyze 命令，以增加数据库中的对象统计信息(object statistics)的准确性。
如果数据库的优化器模式设置为选择性(CHOOSE)，那么实际的优化器模式将和是否运行过analyze命令有关。 如果table已经被analyze过， 优化器模式将自动成为CBO ， 反之，数据库将采用RULE形式的优化器。
在缺省情况下，ORACLE采用CHOOSE优化器，为了避免那些不必要的全表扫描(full table scan) ， 你必须尽量避免使用CHOOSE优化器，而直接采用基于规则或者基于成本的优化器。
2. 访问Table的方式ORACLE 采用两种访问表中记录的方式
a. 全表扫描
全表扫描就是顺序地访问表中每条记录。 ORACLE采用一次读入多个数据块(database block)的方式优化全表扫描。
b. 通过ROWID访问表
你可以采用基于ROWID的访问方式情况，提高访问表的效率， ROWID包含了表中记录的物理位置信息……ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系。 通常索引提供了快速访问ROWID的方法，因此那些基于索引列的查询就可以得到性能上的提高。
3. 共享SQL语句
为了不重复解析相同的SQL语句，在第一次解析之后， ORACLE将SQL语句存放在内存中。这块位于系统全局区域SGA(system global area)的共享池(shared buffer pool)中的内存可以被所有的数据库用户共享。 因此，当你执行一个SQL语句(有时被称为一个游标)时，如果它和之前的执行过的语句完全相同， ORACLE就能很快获得已经被解析的语句以及最好的执行路径。 ORACLE的这个功能大大地提高了SQL的执行性能并节省了内存的使用。
可惜的是ORACLE只对简单的表提供高速缓冲(cache buffering) ，这个功能并不适用于多表连接查询。数据库管理员必须在init.ora中为这个区域设置合适的参数，当这个内存区域越大，就可以保留更多的语句，当然被共享的可能性也就越大了。当你向ORACLE 提交一个SQL语句，ORACLE会首先在这块内存中查找相同的语句。
这里需要注明的是，ORACLE对两者采取的是一种严格匹配，要达成共享，SQL语句必须完全相同(包括空格，换行等)。
共享的语句必须满足三个条件：
A. 字符级的比较：
当前被执行的语句和共享池中的语句必须完全相同。
例如：
SELECT * FROM EMP;
和下列每一个都不同
SELECT * from EMP;
Select * From Emp;
SELECT * FROM EMP;
B. 两个语句所指的对象必须完全相同：
例如：
用户 对象名 如何访问
Jack sal_limit private synonym
Work_city public synonym
Plant_detail public synonym
Jill sal_limit private synonym
Work_city public synonym
Plant_detail table owner
考虑一下下列SQL语句能否在这两个用户之间共享。
C. 两个SQL语句中必须使用相同的名字的绑定变量(bind variables)
例如：第一组的两个SQL语句是相同的(可以共享)，而第二组中的两个语句是不同的(即使在运行时，赋于不同的绑定变量相同的值)
a.
selectpin，namefrompeoplewherepin=：blk1.pin;
selectpin，namefrompeoplewherepin=：blk1.pin;
b.
selectpin，namefrompeoplewherepin=：blk1.ot_ind;
selectpin，namefrompeoplewherepin=：blk1.ov_ind;
4. 选择最有效率的表名顺序(只在基于规则的优化器中有效)
ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名，因此FROM子句中写在最后的表(基础表 driving table)将被最先处理。 在FROM子句中包含多个表的情况下，你必须选择记录条数最少的表作为基础表。当ORACLE处理多个表时， 会运用排序及合并的方式连接它们。首先，扫描第一个表(FROM子句中最后的那个表)并对记录进行派序，然后扫描第二个表(FROM子句中最后第二个表)，最后将所有从第二个表中检索出的记录与第一个表中合适记录进行合并。
例如：
表 TAB1 16，384 条记录
表 TAB2 1 条记录
选择TAB2作为基础表 (最好的方法)
select count(*) from tab1，tab2 执行时间0.96秒
选择TAB2作为基础表 (不佳的方法)
select count(*) from tab2，tab1 执行时间26.09秒
如果有3个以上的表连接查询， 那就需要选择交叉表(intersection table)作为基础表， 交叉表是指那个被其他表所引用的表。
例如： EMP表描述了LOCATION表和CATEGORY表的交集。
SELECT *
FROM LOCATION L ,
CATEGORY C,
EMP E
WHERE E.EMP_NO BETWEEN 1000 AND 2000
AND E.CAT_NO = C.CAT_NO
AND E.LOCN = L.LOCN
将比下列SQL更有效率
SELECT *
FROM EMP E ,
LOCATION L ,
CATEGORY C
WHERE E.CAT_NO = C.CAT_NO
AND E.LOCN = L.LOCN
AND E.EMP_NO BETWEEN 1000 AND 2000
1. WHERE子句中的连接顺序。
ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前， 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。
例如：
(低效，执行时间156.3秒)
SELECT…
FROMEMPE
WHERESAL>50000
ANDJOB=‘MANAGER’
AND25<(SELECTCOUNT(*)FROMEMP
WHEREMGR=E.EMPNO);
(高效,执行时间10.6秒)
SELECT…
FROMEMPE
WHERE25<(SELECTCOUNT(*)FROMEMP
WHEREMGR=E.EMPNO)
ANDSAL>50000
ANDJOB=‘MANAGER’;
2. SELECT子句中避免使用 ‘ * ’
当你想在SELECT子句中列出所有的COLUMN时，使用动态SQL列引用 ‘*’ 是一个方便的方法。不幸的是，这是一个非常低效的方法。 实际上，ORACLE在解析的过程中， 会将‘*’ 依次转换成所有的列名， 这个工作是通过查询数据字典完成的， 这意味着将耗费更多的时间。
3. 减少访问数据库的次数
当执行每条SQL语句时， ORACLE在内部执行了许多工作： 解析SQL语句， 估算索引的利用率， 绑定变量 ， 读数据块等等。 由此可见， 减少访问数据库的次数 ， 就能实际上减少ORACLE的工作量。
例如，以下有三种方法可以检索出雇员号等于0342或0291的职员。
方法1 (最低效)
SELECTEMP_NAME,SALARY,GRADE
FROMEMP
WHEREEMP_NO=342;
SELECTEMP_NAME,SALARY,GRADE
FROMEMP
WHEREEMP_NO=291;
方法2 (次低效)
DECLARE
CURSORC1(E_NONUMBER)IS
SELECTEMP_NAME,SALARY,GRADE
FROMEMP
WHEREEMP_NO=E_NO;
BEGIN
OPENC1(342);
FETCHC1INTO…,..,..;
OPENC1(291);
FETCHC1INTO…,..,..;
CLOSEC1;
END;
方法3 (高效)
以下是引用片段：
SELECTA.EMP_NAME,A.SALARY,A.GRADE,
B.EMP_NAME,B.SALARY,B.GRADE
FROMEMPA,EMPB
WHEREA.EMP_NO=342
ANDB.EMP_NO=291;
注意：
在SQL*Plus ， SQL*Forms和Pro*C中重新设置ARRAYSIZE参数， 可以增加每次数据库访问的检索数据量 ，建议值为200.
4. 使用DECODE函数来减少处理时间
使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表。
例如：
SELECTCOUNT(*)，SUM(SAL)
FROM EMP
WHEREDEPT_NO=0020
ANDENAMELIKE ‘SMITH%’;
SELECTCOUNT(*)，SUM(SAL)
FROM EMP
WHEREDEPT_NO=0030
ANDENAMELIKE ‘SMITH%’;
你可以用DECODE函数高效地得到相同结果
SELECTCOUNT(DECODE(DEPT_NO,0020,’X’,NULL))D0020_COUNT,
COUNT(DECODE(DEPT_NO,0030,’X’,NULL))D0030_COUNT,
SUM(DECODE(DEPT_NO,0020,SAL,NULL))D0020_SAL,
SUM(DECODE(DEPT_NO,0030,SAL,NULL))D0030_SAL
FROMEMPWHEREENAMELIKE‘SMITH%’;
类似的，DECODE函数也可以运用于GROUP BY 和ORDER BY子句中。
5. 整合简单，无关联的数据库访问
如果你有几个简单的数据库查询语句，你可以把它们整合到一个查询中(即使它们之间没有关系)
例如：
SELECTNAME
FROMEMP
WHEREEMP_NO=1234;
SELECTNAME
FROMDPT
WHEREDPT_NO=10;
SELECTNAME
FROMCAT
WHERECAT_TYPE=‘RD’;
上面的3个查询可以被合并成一个：
SELECTE.NAME,D.NAME,C.NAME
FROMCATC,DPTD,EMPE,DUALX
WHERENVL(‘X’,X.DUMMY)=NVL(‘X’,E.ROWID(+))
ANDNVL(‘X’,X.DUMMY)=NVL(‘X’,D.ROWID(+))
ANDNVL(‘X’,X.DUMMY)=NVL(‘X’,C.ROWID(+))
ANDE.EMP_NO(+)=1234
ANDD.DEPT_NO(+)=10
ANDC.CAT_TYPE(+)=‘RD’;
1. 删除重复记录
最高效的删除重复记录方法 ( 因为使用了ROWID)
DELETE FROM EMP E
WHERE E.ROWID > (SELECT MIN(X.ROWID)
FROM EMP X
WHERE X.EMP_NO = E.EMP_NO);
2. 用TRUNCATE替代DELETE
当删除表中的记录时，在通常情况下， 回滚段(rollback segments ) 用来存放可以被恢复的信息。 如果你没有COMMIT事务，ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况)
而当运用TRUNCATE时， 回滚段不再存放任何可被恢复的信息。当命令运行后，数据不能被恢复。因此很少的资源被调用，执行时间也会很短。
(译者按： TRUNCATE只在删除全表适用，TRUNCATE是DDL不是DML)
３. 尽量多使用COMMIT
只要有可能，在程序中尽量多使用COMMIT， 这样程序的性能得到提高，需求也会因为COMMIT所释放的资源而减少：COMMIT所释放的资源：
a. 回滚段上用于恢复数据的信息。
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费
(译者按： 在使用COMMIT时必须要注意到事务的完整性，现实中效率和事务完整性往往是鱼和熊掌不可得兼)
４. 计算记录条数
和一般的观点相反， count(*) 比count(1)稍快 ， 当然如果可以通过索引检索，对索引列的计数仍旧是最快的。 例如 COUNT(EMPNO)
(译者按： 在CSDN论坛中，曾经对此有过相当热烈的讨论， 作者的观点并不十分准确，通过实际的测试，上述三种方法并没有显著的性能差别)
５. 用Where子句替换HAVING子句
避免使用HAVING子句， HAVING 只会在检索出所有记录之后才对结果集进行过滤。 这个处理需要排序，总计等操作。 如果能通过WHERE子句限制记录的数目，那就能减少这方面的开销。
例如：
低效
SELECTREGION，AVG(LOG_SIZE)
FROMLOCATION
GROUPBYREGION
HAVINGREGIONREGION!=‘SYDNEY’
ANDREGION!=‘PERTH’
高效
SELECTREGION，AVG(LOG_SIZE)
FROMLOCATION
WHEREREGIONREGION!=‘SYDNEY’
ANDREGION!=‘PERTH’
GROUPBYREGION
(译者按： HAVING 中的条件一般用于对一些集合函数的比较，如COUNT() 等等。 除此而外，一般的条件应该写在WHERE子句中)
6. 减少对表的查询
在含有子查询的SQL语句中，要特别注意减少对表的查询。
例如：
低效
SELECTTAB_NAME
FROMTABLES
WHERETAB_NAME=(SELECTTAB_NAME
FROMTAB_COLUMNS
WHEREVERSION=604)
AND DB_VER=(SELECTDB_VER
FROMTAB_COLUMNS
WHEREVERSION=604)
高效
SELECTTAB_NAME
FROMTABLES
WHERE(TAB_NAME,DB_VER)
=(SELECTTAB_NAME,DB_VER)
FROMTAB_COLUMNS
WHEREVERSION=604)
Update 多个Column 例子：
低效：
UPDATEEMP
SETEMP_CAT=(SELECTMAX(CATEGORY)FROMEMP_CATEGORIES)
1. 使用表的别名(Alias)
当在SQL语句中连接多个表时， 请使用表的别名并把别名前缀于每个Column上。这样一来，就可以减少解析的时间并减少那些由Column歧义引起的语法错误。
(Column歧义指的是由于SQL中不同的表具有相同的Column名，当SQL语句中出现这个Column时，SQL解析器无法判断这个Column的归属)
2. 用EXISTS替代IN
在许多基于基础表的查询中，为了满足一个条件，往往需要对另一个表进行联接。在这种情况下， 使用EXISTS(或NOT EXISTS)通常将提高查询的效率。
低效：
SELECT*
FROMEMP(基础表)
WHEREEMPNO>0
ANDDEPTNOIN(SELECTDEPTNO
FROMDEPT
WHERELOC=‘MELB’)
高效：
SELECT*
FROMEMP(基础表)
WHEREEMPNO>0
ANDEXISTS(SELECT‘X’
FROMDEPT
WHEREDEPT.DEPTNO=EMP.DEPTNO
ANDLOC=‘MELB’)
(相对来说，用NOT EXISTS替换NOT IN 将更显著地提高效率，下面将指出)
3. 用NOT EXISTS替代NOT IN
在子查询中，NOT IN子句将执行一个内部的排序和合并。 无论在哪种情况下，NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历)。 为了避免使用NOT IN ，我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.
例如：
SELECT…
FROMEMP
WHEREDEPT_NONOTIN(SELECTDEPT_NO
FROMDEPT
WHEREDEPT_CAT=’A’);
为了提高效率。改写为：
(方法一： 高效)
SELECT….
FROMEMPA,DEPTB
WHEREA.DEPT_NO=B.DEPT(+)
ANDB.DEPT_NOISNULL
ANDB.DEPT_CAT(+)=‘A’
1. 用EXPLAIN PLAN 分析SQL语句
EXPLAIN PLAN 是一个很好的分析SQL语句的工具，它甚至可以在不执行SQL的情况下分析语句。 通过分析，我们就可以知道ORACLE是怎么样连接表，使用什么方式扫描表(索引扫描或全表扫描)以及使用到的索引名称。
你需要按照从里到外，从上到下的次序解读分析的结果。 EXPLAIN PLAN分析的结果是用缩进的格式排列的， 最内部的操作将被最先解读， 如果两个操作处于同一层中，带有最小操作号的将被首先执行。
NESTED LOOP是少数不按照上述规则处理的操作， 正确的执行路径是检查对NESTED LOOP提供数据的操作，其中操作号最小的将被最先处理。
通过实践， 感到还是用SQLPLUS中的SET TRACE 功能比较方便。
举例：
SQL> list
1 SELECT *
2 FROM dept, emp
3* WHERE emp.deptno = dept.deptno
SQL> set autotrace traceonly /*traceonly 可以不显示执行结果*/
SQL> /
14 rows selected.
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 NESTED LOOPS
2 1 TABLE ACCESS (FULL) OF 'EMP'
3 1 TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
4 3 INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
Statistics
----------------------------------------------------------
0 recursive calls
2 db block gets
30 consistent gets
0 physical reads
0 redo size
2598 bytes sent via SQL*Net to client
503 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
14 rows processed
通过以上分析，可以得出实际的执行步骤是：
1. TABLE ACCESS (FULL) OF 'EMP'
2. INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
3. TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
4. NESTED LOOPS (JOINING 1 AND 3)
注： 目前许多第三方的工具如TOAD和ORACLE本身提供的工具如OMS的SQL Analyze都提供了极其方便的EXPLAIN PLAN工具。也许喜欢图形化界面的朋友们可以选用它们。
2. 用索引提高效率
索引是表的一个概念部分，用来提高检索数据的效率。 实际上，ORACLE使用了一个复杂的自平衡B-tree结构。 通常，通过索引查询数据比全表扫描要快。 当ORACLE找出执行查询和Update语句的最佳路径时， ORACLE优化器将使用索引。 同样在联结多个表时使用索引也可以提高效率。 另一个使用索引的好处是，它提供了主键(primary key)的唯一性验证。
除了那些LONG或LONG RAW数据类型， 你可以索引几乎所有的列。 通常， 在大型表中使用索引特别有效。 当然，你也会发现， 在扫描小表时，使用索引同样能提高效率。
虽然使用索引能得到查询效率的提高，但是我们也必须注意到它的代价。 索引需要空间来存储，也需要定期维护， 每当有记录在表中增减或索引列被修改时， 索引本身也会被修改。 这意味着每条记录的INSERT ， DELETE ， UPDATE将为此多付出4 ， 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理，那些不必要的索引反而会使查询反应时间变慢。
定期的重构索引是有必要的。
ALTER INDEX REBUILD
3. 索引的操作
ORACLE对索引有两种访问模式。
索引唯一扫描 ( INDEX UNIQUE SCAN)
大多数情况下， 优化器通过WHERE子句访问INDEX.
表LODGING有两个索引 ： 建立在LODGING列上的唯一性索引LODGING_PK和建立在MANAGER列上的非唯一性索引LODGING$MANAGER.
SELECT*
FROMLODGING
WHERELODGING=‘ROSEHILL’;
在内部 ， 上述SQL将被分成两步执行， 首先 ， LODGING_PK 索引将通过索引唯一扫描的方式被访问 ， 获得相对应的ROWID， 通过ROWID访问表的方式执行下一步检索。
如果被检索返回的列包括在INDEX列中，ORACLE将不执行第二步的处理(通过ROWID访问表)。 因为检索数据保存在索引中， 单单访问索引就可以完全满足查询结果。
下面SQL只需要INDEX UNIQUE SCAN 操作。
SELECTLODGING
FROMLODGING
WHERELODGING=‘ROSEHILL’;
索引范围查询(INDEX RANGE SCAN)
适用于两种情况：
1. 基于一个范围的检索
2. 基于非唯一性索引的检索
例1：
SELECT LODGING FROM LODGING WHERE LODGING LIKE ‘M%’;
WHERE子句条件包括一系列值， ORACLE将通过索引范围查询的方式查询LODGING_PK . 由于索引范围查询将返回一组值， 它的效率就要比索引唯一扫描低一些。
例2：
SELECTLODGING
FROMLODGING
WHEREMANAGER=‘BILLGATES’;
这个SQL的执行分两步， LODGING$MANAGER的索引范围查询(得到所有符合条件记录的ROWID) 和下一步同过ROWID访问表得到LODGING列的值。 由于LODGING$MANAGER是一个非唯一性的索引，数据库不能对它执行索引唯一扫描。
由于SQL返回LODGING列，而它并不存在于LODGING$MANAGER索引中， 所以在索引范围查询后会执行一个通过ROWID访问表的操作。
WHERE子句中， 如果索引列所对应的值的第一个字符由通配符(WILDCARD)开始， 索引将不被采用。在这种情况下，ORACLE将使用全表扫描。
SELECTLODGING
FROMLODGING
WHEREMANAGERLIKE‘%HANMAN’;
1. 基础表的选择
基础表(Driving Table)是指被最先访问的表(通常以全表扫描的方式被访问)。 根据优化器的不同， SQL语句中基础表的选择是不一样的。
如果你使用的是CBO (COST BASED OPTIMIZER)，优化器会检查SQL语句中的每个表的物理大小，索引的状态，然后选用花费最低的执行路径。
如果你用RBO (RULE BASED OPTIMIZER) ， 并且所有的连接条件都有索引对应， 在这种情况下， 基础表就是FROM 子句中列在最后的那个表。
举例：
SELECTA.NAME，B.MANAGER
FROM WORKERA，
LODGINGB
WHERE A.LODGING=B.LODING;
由于LODGING表的LODING列上有一个索引， 而且WORKER表中没有相比较的索引， WORKER表将被作为查询中的基础表。
2. 多个平等的索引
当SQL语句的执行路径可以使用分布在多个表上的多个索引时， ORACLE会同时使用多个索引并在运行时对它们的记录进行合并， 检索出仅对全部索引有效的记录。
在ORACLE选择执行路径时，唯一性索引的等级高于非唯一性索引。 然而这个规则只有当WHERE子句中索引列和常量比较才有效。如果索引列和其他表的索引类相比较。 这种子句在优化器中的等级是非常低的。
如果不同表中两个想同等级的索引将被引用， FROM子句中表的顺序将决定哪个会被率先使用。 FROM子句中最后的表的索引将有最高的优先级。
如果相同表中两个想同等级的索引将被引用， WHERE子句中最先被引用的索引将有最高的优先级。
举例：
DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。
SELECTENAME，
FROMEMP
WHEREDEPT_NO=20
ANDEMP_CAT=‘A’;
这里，DEPTNO索引将被最先检索，然后同EMP_CAT索引检索出的记录进行合并。 执行路径如下：
TABLEACCESSBYROWIDONEMP
AND-EQUAL
INDEXRANGESCANONDEPT_IDX
INDEXRANGESCANONCAT_IDX
3. 等式比较和范围比较
当WHERE子句中有索引列， ORACLE不能合并它们，ORACLE将用范围比较。
举例：
DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。
SELECTENAME
FROMEMP
WHEREDEPTNO>20
ANDEMP_CAT=‘A’;
这里只有EMP_CAT索引被用到，然后所有的记录将逐条与DEPTNO条件进行比较。 执行路径如下：
TABLEACCESSBYROWIDONEMP
INDEXRANGESCANONCAT_IDX
4. 不明确的索引等级
当ORACLE无法判断索引的等级高低差别，优化器将只使用一个索引，它就是在WHERE子句中被列在最前面的。
举例：
DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。
SELECTENAME
FROMEMP
WHEREDEPTNO>20
ANDEMP_CAT>‘A’;
这里， ORACLE只用到了DEPT_NO索引。 执行路径如下：
TABLEACCESSBYROWIDONEMP
INDEXRANGESCANONDEPT_IDX
译者按：我们来试一下以下这种情况：
SQL> select index_name， uniqueness from user_indexes where table_name = 'EMP'；
INDEX_NAME UNIQUENES
------------------------------ ---------
EMPNO UNIQUE
EMPTYPE NONUNIQUE
SQL> select * from emp where empno >= 2 and emp_type = 'A' ；
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
2 1 INDEX （RANGE SCAN） OF 'EMPTYPE' （NON-UNIQUE
虽然EMPNO是唯一性索引，但是由于它所做的是范围比较， 等级要比非唯一性索引的等式比较低!
5. 强制索引失效
如果两个或以上索引具有相同的等级，你可以强制命令ORACLE优化器使用其中的一个(通过它，检索出的记录数量少) .
举例：
SELECTENAME
FROMEMP
WHEREEMPNO=7935
ANDDEPTNO+0=10/*DEPTNO上的索引将失效*/
ANDEMP_TYPE||‘’=‘A’/*EMP_TYPE上的索引将失效*/
这是一种相当直接的提高查询效率的办法。 但是你必须谨慎考虑这种策略，一般来说，只有在你希望单独优化几个SQL时才能采用它。
这里有一个例子关于何时采用这种策略，
假设在EMP表的EMP_TYPE列上有一个非唯一性的索引而EMP_CLASS上没有索引。
SELECTENAME
FROMEMP
WHEREEMP_TYPE=‘A’
ANDEMP_CLASS=‘X’;
优化器会注意到EMP_TYPE上的索引并使用它。 这是目前唯一的选择。 如果，一段时间以后， 另一个非唯一性建立在EMP_CLASS上，优化器必须对两个索引进行选择，在通常情况下，优化器将使用两个索引并在他们的结果集合上执行排序及合并。 然而，如果其中一个索引(EMP_TYPE)接近于唯一性而另一个索引(EMP_CLASS)上有几千个重复的值。 排序及合并就会成为一种不必要的负担。 在这种情况下，你希望使优化器屏蔽掉EMP_CLASS索引。
用下面的方案就可以解决问题。
SELECTENAME
FROMEMP
WHEREEMP_TYPE=‘A’
ANDEMP_CLASS||‘’=‘X’;
1. 避免在索引列上使用计算
WHERE子句中，如果索引列是函数的一部分。优化器将不使用索引而使用全表扫描。
举例：
低效：
SELECT…
FROMDEPT
WHERESAL*12>25000;
高效：
SELECT…
FROMDEPT
WHERESAL>25000/12;
：这是一个非常实用的规则，请务必牢记
2. 自动选择索引
如果表中有两个以上(包括两个)索引，其中有一个唯一性索引，而其他是非唯一性。
在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引。
举例：
SELECTENAME
FROMEMP
WHEREEMPNO=2326
ANDDEPTNO=20;
这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录。
TABLEACCESSBYROWIDONEMP
INDEXUNIQUESCANONEMP_NO_IDX
3. 避免在索引列上使用NOT
通常，我们要避免在索引列上使用NOT， NOT会产生在和在索引列上使用函数相同的影响。 当ORACLE“遇到”NOT，他就会停止使用索引转而执行全表扫描。
举例：
低效： (这里，不使用索引)
SELECT…
FROMDEPT
WHEREDEPT_CODENOT=0;
高效： (这里，使用了索引)
SELECT…
FROMDEPT
WHEREDEPT_CODE>0;
需要注意的是，在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符。
NOT > to <=
NOT >= to <
NOT < to >=
NOT <= to >
：在这个例子中，作者犯了一些错误。 例子中的低效率SQL是不能被执行的。
我做了一些测试：
SQL> select * from emp where NOT empno > 1；
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
2 1 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
SQL> select * from emp where empno <= 1；
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
2 1 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
两者的效率完全一样，也许这符合作者关于“ 在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点。
4. 用>=替代>
如果DEPTNO上有一个索引，
高效：
SELECT*
FROMEMP
WHEREDEPTNO>=4
低效：
SELECT*
FROMEMP
WHEREDEPTNO>3
两者的区别在于， 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录。
1. 避免在索引列上使用计算
WHERE子句中，如果索引列是函数的一部分。优化器将不使用索引而使用全表扫描。
举例：
低效：
SELECT…
FROMDEPT
WHERESAL*12>25000;
高效：
SELECT…
FROMDEPT
WHERESAL>25000/12;
：这是一个非常实用的规则，请务必牢记
2. 自动选择索引
如果表中有两个以上(包括两个)索引，其中有一个唯一性索引，而其他是非唯一性。
在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引。
举例：
SELECTENAME
FROMEMP
WHEREEMPNO=2326
ANDDEPTNO=20;
这里，只有EMPNO上的索引是唯一性的，所以EMPNO索引将用来检索记录。
TABLEACCESSBYROWIDONEMP
INDEXUNIQUESCANONEMP_NO_IDX
3. 避免在索引列上使用NOT
通常，我们要避免在索引列上使用NOT， NOT会产生在和在索引列上使用函数相同的影响。 当ORACLE“遇到”NOT，他就会停止使用索引转而执行全表扫描。
举例：
低效： (这里，不使用索引)
SELECT…
FROMDEPT
WHEREDEPT_CODENOT=0;
高效： (这里，使用了索引)
SELECT…
FROMDEPT
WHEREDEPT_CODE>0;
需要注意的是，在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符。
NOT > to <=
NOT >= to <
NOT < to >=
NOT <= to >
：在这个例子中，作者犯了一些错误。 例子中的低效率SQL是不能被执行的。
我做了一些测试：
SQL> select * from emp where NOT empno > 1；
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
2 1 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
SQL> select * from emp where empno <= 1；
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
2 1 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
两者的效率完全一样，也许这符合作者关于“ 在某些时候， ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点。
4. 用>=替代>
如果DEPTNO上有一个索引，
高效：
SELECT*
FROMEMP
WHEREDEPTNO>=4
低效：
SELECT*
FROMEMP
WHEREDEPTNO>3
两者的区别在于， 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录。
{http://blog.chinaunix.net/u/20483/showart_546882.html}
posted @
2008-04-20 11:33 虎啸龙吟 阅读(918) |
评论 (0) |
编辑 收藏
http://blog.chinaunix.net/u/21684/showart.php?id=537094
posted @
2008-04-20 11:10 虎啸龙吟 阅读(336) |
评论 (0) |
编辑 收藏
http://www.blogjava.net/zhangchao/archive/2008/03/19/187372.html
posted @
2008-03-20 09:11 虎啸龙吟 阅读(293) |
评论 (0) |
编辑 收藏
http://www.smellcode.cn/index.php/javascript/jiyuext20dehanyoucheckboxdetree/
posted @
2008-03-20 09:08 虎啸龙吟 阅读(407) |
评论 (0) |
编辑 收藏
http://www.blogjava.net/amigoxie/archive/2008/02/20/180779.html
posted @
2008-03-17 20:14 虎啸龙吟 阅读(184) |
评论 (0) |
编辑 收藏
http://www.blogjava.net/pdw2009/archive/2006/05/10/45461.html
posted @
2008-03-09 15:15 虎啸龙吟 阅读(170) |
评论 (0) |
编辑 收藏