一、Regexp类的一些方法：

    Regexp.new/compile (string/regexp,[options,[lang]]) : 构造一个正则表达式对象。第一个参数是一个字符串或者正则表达式；第二个参数是 正则表达式修饰符的按位OR。

    Regexp.escape/quote (string) : 对正则表达式中的特殊字符进行转义。如：

Regexp.escape('\\*?{}.')   #=> \\\\\*\?\{\}\.

 rxp.match (str) : 返回一个表示匹配结果的MatchData 对象。如果没有匹配则返回nil

str = "a123b456c789"
refs = /(a\d+)(b\d+)(c\d+)/.match(str)
puts refs[0]   # "a123b456c789" 
puts refs[1,3]  # ["a123","b456","c789"]
refs.to_a.each {x| x}   # MatchData对象不是数组，在进行迭代前要调用to_a方法将其转换为一个数组。

 也可以使用全局变量$1,$2等引用匹配结果：

refs = /(a\d+)(b\d+)(c\d+)/.match("a123b456c789")
puts "'#$1','#$2','$3'"  # 'a123','b456','c789'

在sub、gsub等方法中， 不能使用$1等来引用结果，因为这些参数在调用方法前就已经计算好。这时，可以采用特殊编码\1,\2等：

refs = /(a\d+)(b\d+)(c\d+)/.match("a123b456c789")
puts "'#$1','#$2','$3'"  # 'a123','b456','c789'
"a123b456c789".sub(/(a\d+)(b\d+)(c\d+)/, '1st=\1, 2nd=\2, 3rd=\3')   # 1st=a123, 2nd=b456, 3rd=c789
"a123b456c789".sub(/(a\d+)(b\d+)(c\d+)/, "1st=\\1, 2nd=\\2, 3rd=\\3")   # 1st=a123, 2nd=b456, 3rd=c789
# 上面两个sub方法中，第一个使用的是单引号；第二个是双引号，需要使用双语义

MatchData对象还有以下一些有用的方法：

1. begin(n) : 返回第n个匹配开头的偏移量

2. end(n) : 返回第n个匹配结束的偏移量（等于第n+1个匹配的开头偏移量）

3. offset(n) : 返回一个包含第n个匹配开头和结束偏移量的数组

4. pre_match : 返回匹配子字符串前面的字符串部分

5. post_match : 返回匹配子字符串后面的字符串部分

二、一些常用的标记

1.  ^ 和 $   : 行或字符串开头/结尾（注意：匹配单行的行头/行尾）。

src = "abc\ndef\nghi"
/^abc/ =～ src  #0
/^def/ =～ src   #4
/def$/ =～ src   #4
/ghi$/ =～ src  #8

2. \A 和 \Z : 整个字符串的开头/末尾或最后的换行符前

     \z : 基本同 \Z，但是不能匹配最后的换行符

src = "abc\ndef\nghi"
/\Aabc/ =～ src  #0
/\Adef/ =～ src   #nil
/def\Z/ =～ src   #nil
/ghi\Z/ =～ src  #8
/ghi\z/ =～ src  #8
src << "\n"
/ghi\Z/ =～ src  #8
/ghi\z/ =～ src  #nil

3. \b : 单词边界（在[]外）； \B : 非单词边界

src = "this is a test"
src.gsub(/\b/, '|')  # "|this| |is| |a| |test|"
src.gsub(/\B/, '-')  # "t-h-i-s i-s a t-e-s-t"

4. {?=} : 正预查 ，当匹配子字符串sub后面接着的字符串与预查中=号后面的字符串匹配时，sub才匹配成功；{?!}: 负预查，当匹配子字符串sub后面接着的字符串与预查中=号后面的字符串不匹配时，sub才匹配成功。

/(a\d+)(?=b)(b\d+)(c\d+)/.match("a123b456c789")    # ['a123','b456','c789']
 /(a\d+)(?=c)(b\d+)(c\d+)/.match("a123b456c789")    # nil
 /(a\d+)(?=b)(\d+)(c\d+)/.match("a123b456c789")     # nil

 /(a\d+)(?!c)(b\d+)(c\d+)/.match("a123b456c789")    # ['a123','b456','c789'

5. () : 子表达式编组； (?:) : 非捕获组

refs = /(a\d+)(b\d+)(c\d+)/.match("a123b456c789")
puts "'#$1','#$2','$3'"  # 'a123','b456','c789'

refs = /(a\d+)(?:b\d+)(c\d+)/.match("a123b456c789")
puts "'#$1','#$2','$3'"  # 'a123','c789','nil'

6. 字符类：包括在方括号[]中的一组字符，其中每一个子匹配是任意一个字符。

    (1) ^用于字符类的开头时有特殊意义，它对字符列表取反。

    (2) 像.和?之类的元字符在字符类中没有特殊含义，表示自身代表的字符。而\n这样的转义序列仍然有效。

    (3) 连字符-用于字符类的开头或结尾，脱字符^用于字符类的中间时，没有特殊含义，只表示自身；左括号[和右括号]用于字符类中时，也是如此，而且还必须显示进行转义。

/[abc]/ =~ "abcd"   #0
/[^abc]/ =~ "abcd"   #3

/[.?abc]/ =~ ".?"   #0

/[-^\[\]]/ =~ "^" #0

       7. 几个修饰符的介绍

           (1) i    :  正则表达式不区分大小写

           (2) o  :  只执行一次表达式替换

           (3) m   :  多行模式（句点匹配换行）

           (4) x    :  扩展正则表达式（允许空白、注释）

三、一些常用正则表达式实例

1. 匹配IP地址

num = /\d|[01]?\d\d|2[0-4]\d|25[0-5]/
ip = /^(#{num}\.){3}#{num}$/

ip =~ '192.168.0.50'  # 0
ip =~ '192.168.0.500'  # nil

2. 匹配email地址

before_at = /([a-zA-Z0-9]+(_?[a-zA-Z0-9])+)/
after_at = /[a-zA-Z]+(-?[a-zA-Z])+(\.[a-zA-Z]+)+/
email = /^(#{before_at}@#{after_at})$/

email =~ 'abc_123@xyz.com.cn' #0
email =~ 'abc_123@xyz.com' #0
email =~ 'abc_@xyz.com.cn' #nil
email =~ 'abc_123@xy-z.com.cn' #0
email =~ 'abc_123@xyz-.com.cn' #nil

3. 匹配时间/日期类型（yyyy.mm.dd hh:mm:ss）

yyyy = /[1-9]\d\d\d/
mm = /0?[1-9]|1[12]/
dd = /0?[1-9]|[12]\d|3[01]/
hh = /[01]?[1-9]|2[0-4]/
MM = /[0-5]\d/
ss = /[0-5]\d/
date_time = /^(#{yyyy}\.#{mm}\.#{dd}) (#{hh}:#{MM}:#{ss})$/

date_time =~ '2008.8.27 22:12:10'  # 0
date_time =~ '2008.8.27 22:12:60'  # nil

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

摘引至"JavaScript: The Definitive Guide, 5th Edition " chapter 5 section 4

In JavaScript, numbers, strings, and boolean values are compared by value . In this case, two separate values are involved, and the == and === operators check that these two values are identical.

On the other hand, objects, arrays, and functions are compared by reference . This means that two variables are equal only if they refer to the same object.

The following rules determine whether two values are identical according to the === operator:

• If the two values have different types, they are not identical.

• If both values are numbers and have the same value, they are identical, unless either or both values are NaN , in which case they are not identical. The NaN value is never identical to any other value, including itself! To check whether a value is NaN , use the global isNaN( ) function.

• If both values are strings and contain exactly the same characters in the same positions, they are identical. If the strings differ in length or content, they are not identical. Note that in some cases, the Unicode standard allows more than one way to encode the same string. For efficiency, however, JavaScript's string comparison compares strictly on a character-by-character basis, and it assumes that all strings have been converted to a "normalized form" before they are compared. 

• If both values are the boolean value true or both are the boolean value false , they are identical.

• If both values refer to the same object, array, or function, they are identical. If they refer to different objects (or arrays or functions) they are not identical, even if both objects have identical properties or both arrays have identical elements.

• If both values are null or both values are undefined , they are identical.

The following rules determine whether two values are equal according to the == operator:

• If the two values have the same type, test them for identity. If the values are identical, they are equal; if they are not identical, they are not equal.

• If the two values do not have the same type, they may still be equal. Use the following rules and type conversions to check for equality:

  • If one value is null and the other is undefined , they are equal.

  • If one value is a number and the other is a string, convert the string to a number and try the comparison again, using the converted value.

  • If either value is TRue , convert it to 1 and try the comparison again. If either value is false , convert it to 0 and try the comparison again.

  • If one value is an object and the other is a number or string, convert the object to a primitive and try the comparison again. An object is converted to a primitive value by either its toString( ) method or its valueOf( ) method. The built-in classes of core JavaScript attempt valueOf( ) conversion before toString( ) conversion, except for the Date class, which performs toString( ) conversion. Objects that are not part of core JavaScript may convert themselves to primitive values in an implementation-defined way.

  • Any other combinations of values are not equal.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

var Class=function(B)
{
  var A=function()
  {
    // 存在initialize函数的话就执行此函数，否则直接返回
    // arguments[0] 在什么情况下会 === null ?
    return(arguments[0]!==null&&this.initialize&&$type(this.initialize)=="function")?this.initialize.apply(this,arguments):this;
  };
  $extend(A,this);
  A.prototype=B;
  A.constructor=Class;
  return A;
};

Class.prototype=
{
  extend:function(B)
  {
    var C=new this(null);
    // 属性copy，如果原Class中存在此属性时，根据属性的type
    // 对属性值进行合并或者包装；否则直接设置此属性值
    for(var D in B)
    {
      var A=C[D];
      C[D]=Class.Merge(A,B[D]);
    }
    // 构造新的Class
    return new Class(C);
  }
}

Class.Merge=function(C,D)
{
  // 如果父Class中存在此属性，且不是同一个对象
  if(C&&C!=D)
  {
    var B=$type(D);
    if(B!=$type(C))
    {
      return D;
    }
    switch(B)
    {
      // 如果此属性值是函数类型的话，创建新的函数对象A，将其parent属性
      // 设置为父Class中的同名函数对象，并返回A
      case"function":var A=function()
      {
        // 执行此函数时，会先对当前执行对象（子对象）的parent属性设置为该函数对象的
        // parent属性（函数对象C），也即父Class中的同名函数对象，然后再用
        // 子对象的上下文来执行扩展时定义的该函数对象D。
        // 这样设置以后，在D中要想访问父类中的同名函数对象时（相当于java中在子类中通过super访问父类中的方法），
        // 使用this.parent.call(this)即可。
        this.parent=arguments.callee.parent;
        return D.apply(this,arguments);
      };
      A.parent=C;
      return A;
      # 如果是一般对象的话，进行属性合并后直接返回
      case"object":return $merge(C,D);
    }
  }
  return D;
};

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

js中基于prototype实现继承的基本代码如下所示：

function(SubClass, SuperClass){
    function F(){}
    // 
    F.prototype = SuperClass.prototype;
    // 实现继承的关键，构造 prototype chain
    SubClass.prototype = new F(); // 1
    // 重置子类prototype对象的constructor属性为子类本身。
    SubClass.prototype.constructor = SubClass;
    // 设置子类的superclass属性值为父类的prototype。
    SubClass.superclass = SuperClass.prototype;  // 2
    // 使得在子类中可以通过baseconstructor来访问父类的构造函数。
    SubClass.baseconstructor = SuperClass;
}

 上述代码中有两个值得关注的地方：

（1）语句1处使用了new F()的方式，这里为什么需要专门new一个F对象出来呢？首先我们来看下面的这段代码的结果：

function SP(){this.cls = "super class";}
SP.prototype.print(alert(this.cls););

function SB(){}
SB.prototype = SP.prototype
SB.prototype.print(alert("changed by subclass"));

new SP().print();  // output: changed by subclass

 从结果可知SB prototype对象的改变同时影响到了SP，也即此时SB和SP是共享同一个prototype对象。这是不符合继承的本意的。这里如果将

SB.prototype = SP.prototype

更改为：

SB.prototype = new SP()

则可以避免此问题。这也是代码1处使用了new F() 而不是F.prototype的原因。

这里还有一个疑问就是F在这里具体作用是什么？为什么需要添加F，而不是直接使用new SuperClass() ？

先看下面这段代码：

function SP(){this.cls = "super class";}
SP.prototype.print(alert(this.cls););

function SB(){}
SB.prototype = new SP();

new SB().print();  // super class

function F(){}
F.prototype = SP.prototype;
SB.prototype = new F();

new SB().print();  // undefined

 代码中两次执行print函数打印出的结果分别是“super class” 和 undefined。也即第二次执行此函数时SB对象中不存在cls属性，这正是添加一个空的F函数的作用。它可以避免在子类SB中获得得到在父类SP函数体中定义的属性(this.xxx)。

（2）语句2处SubClass.superclass为SuperClass.prototype，而不是SuperClass本身。关于这一点的说明，引用 http://bbs.51js.com/viewthread.php?tid=72688&page=1&extra=#pid556697 上某位网友的观点：

 Ext中的继承也是基于prototype chain的方式来实现的，在 http://www.javaeye.com/topic/195409 有对其继承方法实现的详细解析。但是，其中有一处代码一直未弄懂其作用：

 if(spp.constructor == Object.prototype.constructor){
                     spp.constructor=sp;
   } 

 这一代码中，if条件成立时有两种可能：（1）sp本身就是Object；（2）函数对象在创建时，其prototype对象的constructor属性值总是指向函数对象本身。因此另一种可能就是sp显示改变了其prototype对象，而新对象的constructor属性值指向的是Object。第1种情况处理没有任何意义，因为此时spp.constructor一定等于sp；那么只可能是第二种情况。一个令人费解的问题是"为什么要到有子类继承时才重置父类protoype对象constructor的值，而不是在显示改变其prototype对象时就设置"。为什么这里需要重置constructor的值呢？结合前后代码来看：

spp = sp.prototype;
sb.superclass=spp;

 if(spp.constructor == Object.prototype.constructor){
                     spp.constructor=sp;
  }  

 同上文中关于语句2处设置子类superclass一样，此处sb的superclass属性设置为了spp，其父类sp的prototype对象。此时，若想访问到父类本身，就只能通过spp的constructor属性。因此，才需要对constructor属性进行判断，将其重置为父类sp。也即，加入此语句的原因是为了能够保证在子类中正确调用到父类的构造函数 ，而不是Object。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

一 js的扫描过程

    js在执行代码之前，会有一个扫描（相当于预编译）的过程，这一过程用于获取定义的变量名和函数对象。主要包括如下几个处理步骤：

1. 碰到了“var instance=xxx;” 这样的语句时，则在当前variable object上添加此属性，赋初值为undefined
2. 碰到了函数的定义"function func(){}"时，则使用此函数定义创建相应的函数对象，然后在varable object对象上添加此属性func，其值为返回的函数对象。
   

    下面来举例分析这一过程。

// a
var local_v = "local v";
global_v = "global v";

alert(local_v);    // 1
alert(global_v); // 2     
  

// b
function func1(){
      alert(local_v);
}

var func2 = function(){
      alert(local_v);
}

func1();  //3
func2();  //4

上面这些代码的执行过程如下：

1. 初始化Global Object即window对象，Variable Object为window对象本身。
2. 扫描源代码，在window对象上添加了 local_v 和 func2 属性，值都为undefined。添加了func1属性，值为该定义返回的函数对象。
3. 执行源代码，将local_v属性赋值为 “local v”，在global object 对象上加上属性  global_v 并赋值为“global v”。
4. 正确打印出 local_v  和 global_v 的值
   
5. 创建匿名函数对象，并将其值赋给“func2”属性。
6. 执行func1()函数，打印出local_v属性的值。
7. 执行func2()函数，打印出local_v属性的值。

     在这一分析的基础上，我们将上述代码中的1，2移到a上面；将3，4移到b上面，然后再一次执行。此时，第1条语句打印出的结果是"undefined"，而执行第2条语句时浏览器报错"global_v is not defined"。这是因为window对象上已经有local_v属性了，只是没有显示赋值；而global_v属性此时还不存在；同理，第3条语句正确输出了结果；而第4条语句则报错"func2 is not a function"。因为此时func1已经赋值为函数对象；而func2却没有。

     理解了js的这一执行模型，则能够正确回答出一些容易混淆的问题，比如如下的代码：

var x='global';
document.writeln(x);   // 1
func();

function func(){
    var x='func';
    function inner(){
       document.writeln(x);   // 2
       var x='inner';
       document.writeln(x);  // 3
    }
    inner();
    document.writeln(x);  // 4
} 

如上所示，如果对执行模型不是很清楚的话，很可能会以为第2条语句会输出"func"或者"inner"。

正确的输出结果应该是：  global    undefined    inner   func 。 第2条语句在执行之前，inner函数内的 variable object上用新的x属性值替代了scope chain上在func函数内的属性值，新值因为在此语句处还未赋值，故打印出的结果是"undefined"

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

1. works with Transactions

transaction 1 :
start transaction;
select count(*) from parent;  //  result: 1   QCache_hits : 0
select count(*) from parent;  //  result: 1   QCache_hits : 1

transaction 2 :
start transaction;
select count(*) from parent;  //  result: 1   QCache_hits : 2
insert into parent(name) values('new');
select count(*) from parent;  //  result: 2   QCache_hits : 2

transaction 1 :
select count(*) from parent;  //  result: 1   QCache_hits : 2




transaction 2 :
commit;

transaction 1 :
select count(*) from parent;  //  result: 1   QCache_hits : 2

commit;
select count(*) from parent;  //  result: 2   QCache_hits : 2



select count(*) from parent;  //  result: 2   QCache_hits : 3

transaction 2 :
select count(*) from parent;  //  result: 2   QCache_hits : 4

 the experiment result perfectly explains  the mechanism of mysql cache query with transactions.

2. WhiteSpace and comments

select count(*) from parent;  //  QCache_hits : 0
select count(*) from parent;  //  QCache_hits : 1
/*comment*/ select count(*) from parent;  //  QCache_hits : 2             //  whitespace and comment at the start of query 
/*newcomment*/ select count(*) from parent;  //  QCache_hits : 3      //   does not block query from
/*comment*/select count(*) from parent;  //  QCache_hits : 4              //   being cached.

select /*comment*/ count(*) from parent;  //  QCache_hits : 4             // comments inside
select /*new comment*/ count(*) from parent;  //  QCache_hits : 5

select /*comment*/count(*) from parent;  //  QCache_hits : 5         // no whitespace between count(*) and comments.
select /*newcomment*/count(*) from parent;  //  QCache_hits : 6

select /*comment*/   count(*) from parent;  //  QCache_hits : 6      // one more whitespace before count(*)

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

the difference between prototype property and [[prototype]] which constructs the chain of prorotype

1. each object has a inner property called '[[prototype]] ', whose value is null or point to some object. This property is visible only for JS engine.(in firefox, this property can visited by name '__proto__ ' in js code)
   
2. each Function object has a explicit property called 'prototype '
3. the steps of finding a property property_name in an object obj :
   
   1. return the value of obj.property_name if obj has the property.
   2. return undefined if obj .__proto__ is null
   3. return the value of obj .__proto__.property_name
4. let's take an example to view the values of the two properties  in  some  objects with different types.

   function func(){}
   
   var func_instance = new func();
   var obj_instance = new Object();
   

    we created three objects: a Function object func, an object func_instance created by func and an object obj_instace created by Object. By default, the prototype property of func is point to an object whose  constructor property is point to func itself (it means func.prototype.constructor == func ),  so the chain of [[prototype]] of the object created by func is point to Object.prototype ; the [[prototype]] property is assigned to Function.prototype .  The proptotype property of func_instance is undefined, and the [[prototype]] property is the value of func.prototype . The obj_instance is mostly the same as func_instance, but the value of [[prototype]] is depended on the type of obj_instance. For example, if the expression is
   

   var str = new Object('str');

    then the value is the built-in String constructor ; if the expression is
   

   var num = new Object(123);

    then the value is the built-in Number constructor . if  new Object() is used , then the value is the built-in Object constructor. 

the process of creating an object. (var f = new func(); as example)

1. create an object obj of built-in Object constructor and initialize it.
2. if the type of func.prototype is Object, then set the [[prototype]] property of f to it. otherwise set the value to initialization, namely, Object.prototype .
   
3. regard obj as this, and call the inner [[call]] method of func with the arguments.
   1. the [[call]] method creates the execution context.
   2. invoke the body of func.
   3. destroy the execution context.
   4. return the value of func if exists, otherwise return undefined.
4. return the return value of [[call]] method if the type of value is Object, otherwise return obj.

from the fourth step, we kown that f maybe is not  the instance of func but of Object, and the result depends on the return value of func. an example shows the two situation:

function  func1(){}
function func2(){return {var1:'var1'};}

var instance1 = new func1();
var instance2 = new func2();

alert(instance1.constructor); // function func1(){}
alert(instance2.constructor); // function Object(){...}

alert(instance1 instanceof func1); // true
alert(instance2 instanceof func2); // false

  one point should notice here is that all objects created by the same function share the same [[prototype]] chain. So each object can only read the property in the [[prototype]] chain, the operation of write  will  result in the creation of a new local prototype with the same name. let's look the following example:

function  func1(){}
function func2(){return {var1:'var1'};}


function func1(){}

function func2(){this.prop = "prop in func2"}

func1.prototype = new func2();

var ins1 = new func1();  
var ins2 = new func2();  

alert(ins1.prop);  // prop in func2
alert(ins2.prop);  // prop in func2

ins1.prop = "prop changed by ins1";

alert(ins1.prop);  // prop changed by ins1
alert(ins2.prop);  // prop in func2

the process of creating an Function object. (take var fn = funcion(args){...}; as example)

1. create an object fn of the built-in Object constructor.
2. assign the value of [[prototype]] property of fn to Function.prototype .
3. set the inner [[call]] property, which is an inner implemented method.
4. set the inner [[construct]] property, which is also an inner impelmented method.
5. set fn.length to args.length, or set to 0 if doesnt specify arguments
6. create an object fnProto using the same logic as new Object();
7. set fnProto.constructor to fn .
8. set fn.prototype to fnproto .
9. return fn.
   

By default, from the seventh and eighth steps, the prototype of fn(any user defined function ) is set to an instance of Object, so the object created by fn has a chain of [[prototype]] which points to Object.prototype. But the behavior can be changed by explicit setting the prototype of fn. here is an example:

function func1(){}
function func2(){}

func2.prototype = new func1();

var ins2 = new func2();
alert(ins2.constructor); // function func1(){}
alert(func2.prototype.constructor); // function func1(){}

the picture of javascript object model (quote from http://www.cnblogs.com/RicCC )

the picture tell us that :

1. Object.prototype is the end of the chain of [[prototype]] , and the [[prototype]] of Object.prototype is null .

2. the chain of [[prototype]] of all function is point to Function.prototype

3. the chain of [[prototype]] of Function point to Function.prototype .

4. the chain of [[prototype]] of Function.prototype is point to Object.prototype .

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

At first, let's look the typical class structure diagram of composite pattern:

Composite pattern is very suitable for Tree structure. The picture showed above defines a Interface Node and two sub concrete tree types  : Leaf  and Branch.  Branch may contains sub branch and leaf. The sample codes for the example are listed below:

public Interface Node{
       public void print();
}

public class leaf implements Node{
      public void print(){ 
             System.out.println("visit leaf...");
      }
}

public class branch implements Node{
       private List<Node> subNodes;

       public void addSubNode(Node subNode){}

       public void removeSubNode(Node subNode){}

       public void print(){
          for(Node node : subNodes){
               node.print();
          }
       }
}

 The code is so unpractical that the print method just show its node type. In a general way,  the requirement might  extended in two directions respectively: 

• add new method for each node
• add new node type in tree hierarchy.

under the first situation,  if we need print the number of  sub nodes  for each node, the easiest way, also the only way, is to  change the print method and plus new logic. That is to say, we need to modify the existed system to satisfy new requirement, which violate the open-closed principle of OOD. So, how can we do it with a  better way? May be a available method is to seperate the hebavior from the node class, namely introduce new class to response for behavior, and node class only contains state data.  So now, it is time that visitor pattern show its power.

the class diagram of visitor pattern as follows:

Compare to the diagram of composite pattern.  it has several extra classes : an integerface Visitor and class PrintVisitor. these classes provide the operation to visit nodes. The sample codes listed below:

public Interface Node{
       public void print();
       public void accept(Visitor v);
}

public class leaf implements Node{
      public void print(){ 
             System.out.println("visit leaf...");
      }
      public void accept(Visitor v){
             v.visit(this); 
      }
}

public class branch implements Node{
       private List<Node> subNodes;

       public void addSubNode(Node subNode){}

       public void removeSubNode(Node subNode){}

       public void print(){
          for(Node node : subNodes){
               node.print();
          }
       }
       public void accept(Visitor v){
             v.visit(this); 
      }
}

public interface Visitor{
      public void visit(Leaf leaf);
      public void visit(Branch branch);
}

public class PrintVisitor implements Visitor{
     public void visit(Leaf leaf){
            leaf.print();
     }
     public void visit(Branch branch){
            branch.print();
     }
} 

 Now, we can simply add a new 'visitor' class to extent node behavior, and need not any modification of existed system.  Visitor pattern works wonderfully here, but it also has some limitation.

1. it only suitable for extending node behavior, not  for adding new node type in tree hierarchy. This is the fatal defect of visitor pattern. Just as we see from the simple codes,  a Visitor encapsulate the behavior of all nodes. So if one more node type is added, the vistor interface and all concrete classes need be modified to add corresponding behavior. Luckily, A variant of visitor pattern called 'acyclic visitor' pattern(avp for short) may solve the problem. The main idea of avp is make the Vistor Interface to be a Marker Interface, and create an corresponding visitor interface for each node type . So the codes using avp may looks like that:

   public Interface Node{
          public void print();
          public void accept(Visitor v);
   }
   
   public class leaf implements Node{
         public void print(){ 
                System.out.println("visit leaf...");
         }
         public void accept(Visitor v){
                LeafVisitor lv = (LeafVisitor)v;
                lv.visit(this); 
         }
   }
   
   public class branch implements Node{
          private List<Node> subNodes;
   
          public void addSubNode(Node subNode){}
   
          public void removeSubNode(Node subNode){}
   
          public void print(){
             for(Node node : subNodes){
                  node.print();
             }
          }
          public void accept(Visitor v){
                BranchVisitor lv = (BranchVisitor)v;
                bv.visit(this); 
         }
   }
   
   public interface Visitor{}
   
   public interface LeafVisitor{
        public void visit(Leaf leaf);
   }
   
   public interface BranchVisitor{
       public void visit(Branch branch);
   }
   
   public class PrintVisitor implements Visitor,LeafVisitor,BranchVisitor{
        public void visit(Leaf leaf){
               leaf.print();
        }
        public void visit(Branch branch){
               branch.print();
        }
   } 
   

    In the 'accpet' method of class node class,  firstly, using up-casting, changes the argument to the visitor interface correspond with the node type. if success, then invokes the 'visit' method of the visitor.
   

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

These contents are refered from a pdf file named 'best practices for web form design '.

information

Layout

• top aligned : for reduced completion times & familiar data input.
• right aligned : when vertical screen space is a constraint.
• left aligned : for unfamiliar, or advanced data entry.

Required Form Fields

• try to avoid optional fileds.
• indicate optional fields: if mosts fields are required.
• indicate required fields: if mosts fields are optional.
• Text is best, but * often  works for required fields.
• Associate indicators with labels.

Field Lengths

• when possible, use field length as an affordance.
• otherwise consider a consistent length that provides enough room for inputs.

Content Grouping

• use relevant content groupings to organize forms.
• use the minimum amount of visual elements necessary to communicate useful relationships.

Action

• avoid secondary actions if possible
• otherwise, ensure a clear visual distinction between primary & secondary actions.

Help & Tips

• minimize the amount of help & tips required to fill out a form
• help visible and adjacent to a data request is most useful
• when lots of unfamiliar data is being requested, consider using a dynamic help system.

interaction

path to completion

• remove all unnecessary data requests
• enable smart defaults
• employ flexible data entry
• illuminate a clear path to completion
• for long forms, show progress & save.

tabbing

• remember to account for tabbing behavior
• use the tabindex attribute to control tabbing order
• consider tabbing expectations when laying out forms.

progressive disclosure

• map progressive disclosure to prioritized user needs.
• most effective when user-initiated.
• maintain a consistent approach.

exposing dependent inputs

• maintain clear relationship between initial selection options
• clearly associate additional inputs with their trigger
• avoid 'jumping' that disassociates initial selection options.

feedback

inline validation

• use inline validation for inputs have potentially high error rates.
• use suggested inputs to disambiguate
• communicate limits.

Errors

• clearly communicate an error has occurred: top placement, visual contrast
• provide actionable remedies to correct errors.
• associate responsible fields with primary error message
• 'Double' the visual language where errors have occurred.

progress

• provide indication of tasks in progress
• disable 'submit' button after user clicks it to avoid duplicate submissions.

success

• clearly communicate a data submission has been successful
• provide feedback in context of data submitted.

Three web form creation tools

• wufoo http://www.wufoo.com
• form assembly http://www.formassembly.com
• icebrrg http://www.icebrrg.com
  

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

At first, lst's understand some technologies used in mysql transaction model:

1. Next-Key Locking

 from the introduction, we kown that the next-key locking is the composite of normal lock and 'gap' lock. Besides locks the selected records, it also locks the 'gap'  the range index scan iterated in the index order.  The explaination may obscure. So i am going to take an example to illustrate it.

There are my testing environment:

(1) in the transaction one(T1 for short) execute the following SQL:

 the records 3 and 5 will be displayed.

Then, in the transaction two(T2 for short) execute an update sql :

 If allthings goes well,  an error message will displayed after several seconds :

 Than , execute three insert sql:

 the first one execute successfully and the others are fail with the same error message as listed above.

(2) restore the records,  and change the sql executed in T1 to :

 then the same three sql in T2 executed again. the result reverse : the first two fail and the last success.

(3) restore the records, then in T1 execute:

 after that, execute the following in T2:

 The result is the two insert sql success and the rest fail.

From the results of  three different  condition,  I think we can clearly realize the meaning of 'gap' lock and  rows actually be locked.

2. Consistent Read

Four transaction levels supported by mysql

1. READ UNCOMMITTED

2. READ COMMITTED

 3. REPEATABLE READ

 4. SERIALIZABLE

 In the rest of the article, i will concentrate on the two widely used isolation levels : READ COMMITTED(RC for short) and REPEATABLE READ(rr for short). introduce their characteristic compare their difference.

(1)     from the introducation of consistent read above, we kown that  it is the default mode of the two isolation levels to process SELECT statment. But there is an important different  between them :  the consistent read , in RR, with the same transaction always read the same snapshot  established by the first of read; in contrast, each consistent read set and reads its own fresh snapshot. in RC. Let's make an experiment.

 The different results of the two situation make it clear that every consistent read always read the snapshot established in the time point the first read executed. So only the operation result of  transaction  committed  before it can be seen.

 Obviously, each consistent read fresh its snapshot and see the lastest committed result.

(2)      different lock mechanism is used for SELECT ... FOR UPDATE and SELECT ... LOCK IN SHARE MODE statements in RC.

 Comparing the result with the example one in the first chapter,  the insert operation here work successfully even though the record id 4 is in the scope of index 'gap' scanned by the select... for update statment. That is to say, in RC,  the select...for update statment does not put  'gap' lock on table.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Three jsp directives

1. the page directive

first, refere the explaination of it in jsp specificiation:

 this directive is so common that always can  be see in the top of JSP pages, and used just like this:

  the directive above indiciates that the scripting language is based on java, and the MIME type is 'text/html' and the character encoding of output is 'utf-8'.

Now that the directive involved the concept of encoding. i will simply explain the difference between charset and pagEcoding .

 In jsp specificiation, the two conceptions are  described as follows:

 as we kown,  JSP page be compiled to servlet in the server side. the value of pageEncoding specifies the encoding would be used to compile the jsp page, otherwise, the web container will make use of the value of file.encoding.  So 'pageEncoding' is the key factor of avoid chinese problem. if we didnt specify it,  the application work correctly when deployed on windows would  occur chinese character problem if was deployed on linux.  On the other side,  ' charset' specifies the encoding of the response of the jsp page. That is to say, the server encoded the data using the encoding specified by 'charset' before sending it to client.

2. the taglib directive

the jsp specificiation defines it as follow:

 typically, this directive is necessary if we wanna use JSTL and struts defined tag library in jsp page.

3. the include directive

 beside the include directive, there is also another way to do the same thing-- using the <jsp:include> action.

 So, ws the difference of the two ways ?  Speak in breaf, the include directive would inserts the text of the included resource to the generated servlet when compiling, in contrast, the other would interpret the response of the included file, and plus it to the itself when visiting the page. In another word, the former is suitable for static resource, and the latter  is suitable for both static and dynamic object.  An example usage listed as follows:

 One important point is that the URI of file/page is relatice to the current jsp file/page. If the uri is started with symbol '/' , it means that the uri is relative to the context of web application.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

in many j2ee applications, especially which developed by light-weight framework,such as struts, we can easily see the url pattern as  follows :

 In contrast, the url pattern used by ruby on rails applications are totally different:

 Compare the two url patterns, I think most people may choose the latter, for its simplicity and beauty. Apparently, the second one reduce the usage of symbol ? and &. beside that , the second one also is  'search engine friendly' -- it has a higher chance  to be searched by searching engine like google. So , hao can we get way from the ugly url pattern  in j2ee applications. the answer is : url-rewrite.

url-rewrite is a technology that  substitute dynamic pages for static pages. for example,  the page /user/list.do?id=123 can be visited by url /url/list/123 if we have configured related url-rewrite rule.

there are two ways to implement url-rewrite in j2ee application:

• using proxy http server. Apache HTTP Server 2.x and mod_proxy provide the url-rewrite function.
• except that, using the third side lib is also a good choice. such as UrlRewriteFilter.

in this topic, i will introduce the second way.(the other would be introduced serval days latter.)

the stepes to use UrlRewriteFilter in ur app as follows:

1. visit web site http://tuckey.org/urlrewrite/   , and downoad the latest version.
2. add the lib urlrewrite-xxx.jar to ur app web-inf/lib folder.
3. add the following to ur web-inf/web.xml:
   
4. <filter>
   <filter-name>UrlRewriteFilter</filter-name>
   <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
   </filter>
   <filter-mapping>
   <filter-name>UrlRewriteFilter</filter-name>
   <url-pattern>/*</url-pattern>
   </filter-mapping>
5. create the file urlrewrite.xml in ur app web-inf/ folder. default, urlRewriteFilter will use the file to apply rewriter rule. add the following content to urlrewrite.xml :
   
6. <urlrewrite>
   
   <rule>
   <from>/([a-zA-Z]+)/([a-zA-Z]+)/([0-9]+)</from>
   <to>/$1/$2.do?id=$3</to>
   </rule>
   
   </urlrewrite>
    the rule displayed above means that any url like /user/list/123 will be rewrited to /user/list.do?id=123.
   
7. after all things above were done rightly. now, we can input the /user/list/123 in browser and the url will be correctly rewrited and display related content.
   

urlrewrite.xml introduction

urlrewrite.xml must have a root element called <urlrewrite></urlrewrite> , and at least contains one "rule" element.

'rule' element is the core of xml. a 'rule' element stand for a  url-rewrite rule. 'rule' element must contains a 'to' and 'from' element, and for some advanced application,  also could contains the optional elements like 'condition' and 'set'. the official site describe the process flow as follows:

 the value specified in 'to' and 'from' elements must be relative to the request context, and  can be a regular expression in the perl5 style.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Criteria criteria = this.getCriteria(Parent.class);
 //连接关联子对象child，且指定了连接方式为左外连接
criteria.createAlias("children", "c", CriteriaSpecification.LEFT_JOIN));
//下面三行代码是用于获取总的记录数
criteria.setProjection(Projections.rowCount());
int size = (Integer) criteria.uniqueResult();
criteria.setProjection(null);

List results = criteria.list();

• CriteriaSpecification.ROOT_ENTITY：就是一个RootEntityResultTransformer 对象，其实现如下：

public Object transformTuple(Object[] tuple, String[] aliases) {
	return tuple[ tuple.length-1 ];
}


由代码可知，它返回值取的是数组中的最后一个对象，也即根实体对象，在上例中就相当于返回Parent对象。
• CriteriaSpecification.DISTINCT_ROOT_ENTITY：就是一个 DistinctRootEntityResultTransformer 对象，它的实现与RootEntityResultTransformer相似，只是在其的基础对根实体对象进行了比较，过滤掉了其中相同的对象。
• CriteriaSpecification.ALIAS_TO_ENTITY_MAP：就是一个AliasToEntityMapResultTransformer 对象，其实现如下：

public Object transformTuple(Object[] tuple, String[] aliases) {
	Map result = new HashMap(tuple.length);
	for ( int i=0; i<tuple.length; i++ ) {
		String alias = aliases[i];
		if ( alias!=null ) {
			result.put( alias, tuple[i] );
		}
	}
	return result;
}


它是对数组中的每一个对象，以其别名为key，对象本身为value，构成了一个map作为返回值。
• CriteriaSpecification.PROJECTION：就是一个 PassThroughResultTransformer 对象，它就是简单地返回数组本身，即上例中第一种情况。

criteria.setProjection(null);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

public class Person implements java.io.Serializable {}

public void serializeObject(){
     String fileName = "ser.out";
     FileOutputStream fos = new FileOutputStream(fileName);
     ObjectOutputStream oos = new ObjectOutputStream(fos);
     oos.writeObject(new Person());
     oos.flush();
}

public void deserializeObject(){
     String fileName = "ser.out";
     FileInputStream fos = new FileInputStream(fileName);
     ObjectInputStream oos = new ObjectInputStream(fos);
     Person p = oos.readObject();
}

• 性能问题
为了序列化类A一个实例对象，所需保存的全部信息如下：
1. 与此实例对象相关的全部类的元数据(metadata)信息；因为继承关系，类A的实例对象也是其任一父类的对象。因而，需要将整个继承链上的每一个类的元数据信息，按照从父到子的顺序依次保存起来。
2. 类A的描述信息。此描述信息中可能包含有如下这些信息：类的版本ID(version ID)、表示是否自定义了序列化实现机制的标志、可序列化的属性的数目、每个属性的名字和值、及其可序列化的父类的描述信息。
3. 将实例对象作为其每一个超类的实例对象，并将这些数据信息都保存起来。
在RMI等远程调用的应用中，每调用一个方法，都需要传递如此多的信息量；久而久之，会对系统的性能照成很大的影响。
• 版本信息
当用readObject()方法读取一个序列化对象的byte流信息时，会从中得到所有相关类的描述信息以及示例对象的状态数据；然后将此描述信息与其本地要构造的类的描述信息进行比较，如果相同则会创建一个新的实例并恢复其状态，否则会抛出异常。这就是序列化对象的版本检测。JVM中默认的描述信息是使用一个长整型的哈希码(hashcode)值来表示，这个值与类的各个方面的信息有关，如类名、类修饰符、所实现的接口名、方法和构造函数的信息、属性的信息等。因而，一个类作一些微小的变动都有可能导致不同的哈希码值。例如开始对一个实例对象进行了序列化，接着对类增加了一个方法，或者更改了某个属性的名称，当再想根据序列化信息来重构以前那个对象的时候，此时两个类的版本信息已经不匹配，不可能再恢复此对象的状态了。要解决这个问题，可能在类中显示定义一个值，如下所示：


private static final long serialVersionUID = ALongValue;


这样，序列化机制会使用这个值来作为类的版本标识符，从而可以解决不兼容的问题。但是它却引入了一个新的问题，即使一个类作了实质性的改变，如增加或删除了一些可序列化的属性，在这种机制下仍然会认为这两个类是相等的。

public void readExternal(ObjectInput in);
public void writeExternal(ObjectOutput out);

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

一 基础知识

二 B-树索引

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

原文地址：http://www.orafaq.com/node/1403

What is an Index?

This is covered in the Oracle Concepts manual, of course, but here's the Cliff Notes version.

Blocks

First you need to understand a block. A block - or page for Microsoft boffins - is the smallest unit of disk that Oracle will read or write. All data in Oracle - tables, indexes, clusters - is stored in blocks. The block size is configurable for any given database but is usually one of 4Kb, 8Kb, 16Kb, or 32Kb. Rows in a table are usually much smaller than this, so many rows will generally fit into a single block. So you never read "just one row"; you will always read the entire block and ignore the rows you don't need. Minimising this wastage is one of the fundamentals of Oracle Performance Tuning.

Oracle uses two different index architectures: b-Tree indexes and bitmap indexes. Cluster indexes, bitmap join indexes, function-based indexes, reverse key indexes and text indexes are all just variations on the two main types. b-Tree is the "normal" index, so we will come back to Bitmap indexes another time.

The "-Tree" in b-Tree

A b-Tree index is a data structure in the form of a tree - no surprises there - but it is a tree of database blocks, not rows. Imagine the leaf blocks of the index as the pages of a phone book.

1. Each page in the book (leaf block in the index) contains many entries, which consist of a name (indexed column value) and an address (ROWID) that tells you the physical location of the telephone (row in the table).
2. The names on each page are sorted, and the pages - when sorted correctly - contain a complete sorted list of every name and address

A sorted list in a phone book is fine for humans, beacuse we have mastered "the flick" - the ability to fan through the book looking for the page that will contain our target without reading the entire page. When we flick through the phone book, we are just reading the first name on each page, which is usually in a larger font in the page header. Oracle cannot read a single name (row) and ignore the reset of the page (block); it needs to read the entire block.

If we had no thumbs, we may find it convenient to create a separate ordered list containing the first name on each page of the phone book along with the page number. This is how the branch-blocks of an index work; a reduced list that contains the first row of each block plus the address of that block. In a large phone book, this reduced list containing one entry per page will still cover many pages, so the process is repeated, creating the next level up in the index, and so on until we are left with a single page: the root of the tree.

To find the name Gallileo in this b-Tree phone book, we:

1. Read page 1. This tells us that page 6 starts with Fermat and that page 7 starts with Hawking.
2. Read page 6. This tells us that page 350 starts with Fyshe and that page 351 starts with Garibaldi.
3. Read page 350, which is a leaf block; we find Gallileo's address and phone number.

That's it; 3 blocks to find a specific row in a million row table. In reality, index blocks often fit 100 or more rows, so b-Trees are typically quite shallow. I have never seen an index with more than 5 levels. Curious? Try this:

SELECT index_name, blevel+1 FROM user_indexes ORDER BY 2;

user_indexes.blevel is the number of branch levels. Always add 1 to include the leaf level; this tells you the number of blocks a unique index scan must read to reach the leaf-block. If you're really, really, insatiably curious; try this in SQL*Plus:

ACCEPT index_name PROMPT "Index Name: "

ALTER SESSION SET TRACEFILE_IDENTIFIER = '&index_name';

COLUMN object_id NEW_VALUE object_id

SELECT object_id
FROM   user_objects
WHERE  object_type = 'INDEX'
AND    object_name = upper('&index_name');

ALTER SESSION SET EVENTS 'IMMEDIATE TRACE NAME TREEDUMP LEVEL &object_id';
ALTER SESSION SET TRACEFILE_IDENTIFIER = "";

SHOW PARAMETER user_dump_dest

Give the name of an index on a smallish table (because this will create a BIG file). Now, on the Oracle server, go to the directory shown by the final SHOW PARAMETER user_dump_dest command and find your trace file - the file name will contain your index name. Here is a sample:

*** 2007-01-31 11:51:26.822
----- begin tree dump
branch: 0x68066c8 109078216 (0: nrow: 325, level: 1)
   leaf: 0x68066c9 109078217 (-1: nrow: 694 rrow: 694)
   leaf: 0x68066ca 109078218 (0: nrow: 693 rrow: 693)
   leaf: 0x68066cb 109078219 (1: nrow: 693 rrow: 693)
   leaf: 0x68066cc 109078220 (2: nrow: 693 rrow: 693)
   leaf: 0x68066cd 109078221 (3: nrow: 693 rrow: 693)
   ...
   ...
   leaf: 0x68069cf 109078991 (320: nrow: 763 rrow: 763)
   leaf: 0x68069d0 109078992 (321: nrow: 761 rrow: 761)
   leaf: 0x68069d1 109078993 (322: nrow: 798 rrow: 798)
   leaf: 0x68069d2 109078994 (323: nrow: 807 rrow: 807)
----- end tree dump

This index has only a root branch with 323 leaf nodes. Each leaf node contains a variable number of index entries up to 807! A deeper index would be more interesting, but it would take a while to dump.

"B" is for...

Contrary to popular belief, b is not for binary; it's balanced.

As you insert new rows into the table, new rows are inserted into index leaf blocks. When a leaf block is full, another insert will cause the block to be split into two blocks, which means an entry for the new block must be added to the parent branch-block. If the branch-block is also full, it too is split. The process propagates back up the tree until the parent of split has space for one more entry, or the root is reached. A new root is created if the root node splits. Staggeringly, this process ensures that every branch will be the same length. Try it on paper for yourself!

How are Indexes used?

Indexes have three main uses:

1. To quickly find specific rows by avoiding a Full Table Scan

   We've already seen above how a Unique Scan works. Using the phone book metaphor, it's not hard to understand how a Range Scan works in much the same way to find all people named "Gallileo", or all of the names alphabetically between "Smith" and "Smythe". Range Scans can occur when we use >, <, LIKE, or BETWEEN in a WHERE clause. A range scan will find the first row in the range using the same technique as the Unique Scan, but will then keep reading the index up to the end of the range. It is OK if the range covers many blocks.

2. To avoid a table access altogether

   If all we wanted to do when looking up Gallileo in the phone book was to find his address or phone number, the job would be done. However if we wanted to know his date of birth, we'd have to phone and ask. This takes time. If it was something that we needed all the time, like an email address, we could save time by adding it to the phone book.

   Oracle does the same thing. If the information is in the index, then it doesn't bother to read the table. It is a reasonably common technique to add columns to an index, not because they will be used as part of the index scan, but because they save a table access. In fact, Oracle may even perform a Fast Full Scan of an index that it cannot use in a Range or Unique scan just to avoid a table access.
   

3. To avoid a sort

   This one is not so well known, largely because it is so poorly documented (and in many cases, unpredicatably implemented by the Optimizer as well). Oracle performs a sort for many reasons: ORDER BY, GROUP BY, DISTINCT, Set operations (eg. UNION), Sort-Merge Joins, uncorrelated IN-subqueries, Analytic Functions). If a sort operation requires rows in the same order as the index, then Oracle may read the table rows via the index. A sort operation is not necessary since the rows are returned in sorted order.

   Despite all of the instances listed above where a sort is performed, I have only seen three cases where a sort is actually avoided.

   1. GROUP BY

        1  select src_sys, sum(actl_expns_amt), count(*)
        2  from ef_actl_expns
        3  where src_sys = 'CDW'
        4  and actl_expns_amt > 0
        5* group by src_sys
      
      -------------------------------------------------------------
      | Id  | Operation                           | Name          |
      -------------------------------------------------------------
      |   0 | SELECT STATEMENT                    |               |
      |   1 |  SORT GROUP BY NOSORT               |               |
      |*  2 |   TABLE ACCESS BY GLOBAL INDEX ROWID| EF_ACTL_EXPNS |
      |*  3 |    INDEX RANGE SCAN                 | EF_AEXP_PK    |
      -------------------------------------------------------------
      
      Predicate Information (identified by operation id):
      ---------------------------------------------------
      
         2 - filter("ACTL_EXPNS_AMT">0)
         3 - access("SRC_SYS"='CDW')

      Note the NOSORT qualifier in Step 1.

   2. ORDER BY

        1  select *
        2  from ef_actl_expns
        3  where src_sys = 'CDW'
        4  and actl_expns_amt > 0
        5* order by src_sys
      
      ------------------------------------------------------------
      | Id  | Operation                          | Name          |
      ------------------------------------------------------------
      |   0 | SELECT STATEMENT                   |               |
      |*  1 |  TABLE ACCESS BY GLOBAL INDEX ROWID| EF_ACTL_EXPNS |
      |*  2 |   INDEX RANGE SCAN                 | EF_AEXP_PK    |
      ------------------------------------------------------------
      
      Predicate Information (identified by operation id):
      ---------------------------------------------------
      
         1 - filter("ACTL_EXPNS_AMT">0)
         2 - access("SRC_SYS"='CDW')
      

      Note that there is no SORT operation, despite the ORDER BY clause. Compare this to the following:

        1  select *
        2  from ef_actl_expns
        3  where src_sys = 'CDW'
        4  and actl_expns_amt > 0
        5* order by actl_expns_amt
      
      -------------------------------------------------------------
      | Id  | Operation                           | Name          |
      -------------------------------------------------------------
      |   0 | SELECT STATEMENT                    |               |
      |   1 |  SORT ORDER BY                      |               |
      |*  2 |   TABLE ACCESS BY GLOBAL INDEX ROWID| EF_ACTL_EXPNS |
      |*  3 |    INDEX RANGE SCAN                 | EF_AEXP_PK    |
      -------------------------------------------------------------
      
      Predicate Information (identified by operation id):
      ---------------------------------------------------
      
         2 - filter("ACTL_EXPNS_AMT">0)
         3 - access("SRC_SYS"='CDW')

   3. DISTINCT

        1  select distinct src_sys
        2  from ef_actl_expns
        3  where src_sys = 'CDW'
        4* and actl_expns_amt > 0
      
      -------------------------------------------------------------
      | Id  | Operation                           | Name          |
      -------------------------------------------------------------
      |   0 | SELECT STATEMENT                    |               |
      |   1 |  SORT UNIQUE NOSORT                 |               |
      |*  2 |   TABLE ACCESS BY GLOBAL INDEX ROWID| EF_ACTL_EXPNS |
      |*  3 |    INDEX RANGE SCAN                 | EF_AEXP_PK    |
      -------------------------------------------------------------
      
      Predicate Information (identified by operation id):
      ---------------------------------------------------
      
         2 - filter("ACTL_EXPNS_AMT">0)
         3 - access("SRC_SYS"='CDW')

      Again, note the NOSORT qualifier.

   This is an extraordinary tuning technique in OLTP systems like SQL*Forms that return one page of detail at a time to the screen. A SQL with a DISTINCT, GROUP BY, or ORDER BY that uses an index to sort can return just the first page of matching rows without having to fetch the entire result set for a sort. This can be the difference between sub-second response time and several minutes or hours.

   Everybody repeat after me: "Full table Scans are not bad"

   Up to now, we've seen how indexes can be good. It's not always the case; sometimes indexes are no help at all, or worse: they make a query slower.

   A b-Tree index will be no help at all in a reduced scan unless the WHERE clause compares indexed columns using >, <, LIKE, IN, or BETWEEN operators. A b-Tree index cannot be used to scan for any NOT style operators: eg. !=, NOT IN, NOT LIKE. There are lots of conditions, caveats, and complexities regarding joins, sub-queries, OR predicates, functions (inc. arithmetic and concatenation), and casting that are outside the scope of this article. Consult a good SQL tuning manual.

   Much more interesting - and important - are the cases where an index makes a SQL slower. These are particularly common in batch systems that process large quantities of data.

   To explain the problem, we need a new metaphor. Imagine a large deciduous tree in your front yard. It's Autumn, and it's your job to pick up all of the leaves on the lawn. Clearly, the fastest way to do this (without a rake, or a leaf-vac...) would be get down on hands and knees with a bag and work your way back and forth over the lawn, stuffing leaves in the bag as you go. This is a Full Table Scan, selecting rows in no particular order, except that they are nearest to hand. This metaphor works on a couple of levels: you would grab leaves in handfuls, not one by one. A Full Table Scan does the same thing: when a bock is read from disk, Oracle caches the next few blocks with the expectation that it will be asked for them very soon. Type this in SQL*Plus:
   

   SHOW PARAMETER db_file_multiblock_read_count
   

   Just to shake things up a bit (and to feed an undiagnosed obsessive compulsive disorder), you decide to pick up the leaves in order of size. In support of this endeavour, you take a digital photograph of the lawn, write an image analysis program to identify and measure every leaf, then load the results into a Virtual Reality headset that will highlight the smallest leaf left on the lawn. Ingenious, yes; but this is clearly going to take a lot longer than a full table scan because you cover much more distance walking from leaf to leaf.

   So obviously Full Table Scan is the faster way to pick up every leaf. But just as obvious is that the index (virtual reality headset) is the faster way to pick up just the smallest leaf, or even the 100 smallest leaves. As the number rises, we approach a break-even point; a number beyond which it is faster to just full table scan. This number varies depending on the table, the index, the database settings, the hardware, and the load on the server; generally it is somewhere between 1% and 10% of the table.

   The main reasons for this are:
   

   1. As implied above, reading a table in indexed order means more movement for the disk head.
   2. Oracle cannot read single rows. To read a row via an index, the entire block must be read with all but one row discarded. So an index scan of 100 rows would read 100 blocks, but a FTS might read 100 rows in a single block.
   3. The db_file_multiblock_read_count setting described earlier means FTS requires fewer visits to the physical disk.
   4. Even if none of these things was true, accessing the entire index and the entire table is still more IO than just accessing the table.

   So what's the lesson here? Know your data! If your query needs 50% of the rows in the table to resolve your query, an index scan just won't help. Not only should you not bother creating or investigating the existence of an index, you should check to make sure Oracle is not already using an index. There are a number of ways to influence index usage; once again, consult a tuning manual. The exception to this rule - there's always one - is when all of the columns referenced in the SQL are contained in the index. If Oracle does not have to access the table then there is no break-even point; it is generally quicker to scan the index even for 100% of the rows.

   Summary

   Indexes are not a dark-art; they work in an entirely predictable and even intuitive way. Understanding how they work moves Performance Tuning from the realm of guesswork to that of science; so embrace the technology and read the manual.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

    public boolean equals(Object obj) {
        return (this == obj);
    }