shieldy's pool

*&---------------------------------------------------------------------*
*& Report  Z_N_QUEEN_BY_NONRECURSIVE
*&
*&---------------------------------------------------------------------*
*& FINISHED BY SEIVIN ZHANG AT 2009-09-24
*&
*&---------------------------------------------------------------------*

REPORT  Z_N_QUEEN_BY_NONRECURSIVE.
*** for show in the statusbar when processing
CALL FUNCTION 'SAPGUI_PROGRESS_INDICATOR'
EXPORTING
TEXT = 'The report is processing the queen problem, please wait for the result.'.

DATA: BEGIN OF ROW ,
  VAL TYPE I,
END OF ROW .
DATA: I_COLUM LIKE ROW OCCURS 0 WITH HEADER LINE . "COLUM OF THE COLISSION
DATA: I_LEFT  LIKE ROW OCCURS 0 WITH HEADER LINE . "LEFT DIAGONAL OF THE COLISSION
DATA: I_RIGHT LIKE ROW OCCURS 0 WITH HEADER LINE . "RIGHT DIAGONAL OF THE COLISSION
DATA: I_COLLISION TYPE I." if I_COLLISION = 0, means no collision, else means collision.
DATA:BEGIN OF queen,
    row TYPE I VALUE '0',
    END OF queen.
DATA: I_QUEEN LIKE QUEEN OCCURS 0 WITH HEADER LINE." QUEEN FOR PRINT.

DATA: OK_TIMES TYPE I VALUE '0'.

******GET THE COUNT OF THE QUEEN
SELECTION-SCREEN COMMENT /12(30) remark.
PARAMETERS: count TYPE I DEFAULT '8'.
INITIALIZATION.
  remark  = 'Please enter the count of queens'.
  count   = '8'.

******PROCESS THE QUEEN PROBLEM
START-OF-SELECTION.
  WRITE: /,'N QUEEN PROBLEM',/.
  IF COUNT > '0' AND COUNT < '20'." IF THE COUNT OF QUEEN IS MORE THAN 20, THE TIME MAYBE UNTOTERANBLE.
    WRITE: /, COUNT,/.
    PERFORM MAIN_PROCESS USING COUNT.
  ELSE.
    WRITE: /, 'WRONG COUNT'.
  ENDIF.

****THE MAIN PROCESS FUNCITON
FORM MAIN_PROCESS USING I_NUM.
 "write: /,'From date:', SY-DATUM, 'time:', SY-UZEIT, /.
************INITIALIZATION**********************
  "initial the queen array
  DO I_NUM TIMES .
    I_QUEEN-ROW = -1 .
    APPEND I_QUEEN .
  ENDDO.
  "initial the colum and left ,right diagonal
  "1-NUM
  DO I_NUM TIMES .
    I_COLUM-VAL = 0 .
    APPEND I_COLUM .
  ENDDO.
  "ROW-COLUM+NUM(1-2*NUM)
  DO I_NUM * 2 TIMES .
    I_LEFT-VAL = 0 .
    APPEND I_LEFT .
  ENDDO.
  "ROW+COLUM(1-2*NUM)
  DO I_NUM * 2 TIMES .
    I_RIGHT-VAL = 0 .
    APPEND I_RIGHT .
  ENDDO.
********END OF INITIALZATION*******************
  " OUTPUT THE COLUM FORMATE.
  DATA I_OUT TYPE I.
  I_OUT = 1.
  WRITE: ' |'.
  DO COUNT TIMES.
    WRITE (2) I_OUT.
    I_OUT = I_OUT + 1.
  ENDDO.
  WRITE: /.
  " END OF THE OUTPUT FORMATE.

  " CALL CORE THE PROCESSING
  PERFORM PROCESS_QUEEN.

  " OUTPUT THE TOTAL OF SOLUTIONL.
  WRITE: /, 'There are ',OK_TIMES, 'in all for the solution of ', COUNT,' queen problem'.
  "write: /, 'To date:', SY-DATUM, 'time:', SY-UZEIT, /.

ENDFORM.   " END OF THE MAIN PROCESS

****the core queen process****
****I_COUNT MEANS PROCESSING THE I_COUNT ROW.
FORM PROCESS_QUEEN .
  DATA: I_COUNT TYPE I," THE ROW FLAG
        J_COUNT TYPE I," THE COLUM FLAG
        K_COUNT TYPE I." THE TEMP COLUM FLAG
  I_COUNT = 1.
  J_COUNT = 0.

  WHILE I_COUNT <= COUNT.
    READ TABLE I_QUEEN INDEX I_COUNT.
    J_COUNT = 0.
    IF I_QUEEN-ROW > 0 AND I_QUEEN-ROW <= COUNT.
      J_COUNT = I_QUEEN-ROW.
      PERFORM SET_QUEEN USING I_COUNT -1.
      PERFORM SET_COLLISION USING I_COUNT J_COUNT 0.
    ENDIF.

    K_COUNT = J_COUNT + 1.
    WHILE K_COUNT <= COUNT.
      PERFORM COLLISION USING I_COUNT K_COUNT.
      IF I_COLLISION = 0.
        PERFORM SET_COLLISION USING I_COUNT K_COUNT 1.
        PERFORM SET_QUEEN USING I_COUNT K_COUNT.

        IF I_COUNT = COUNT.
          PERFORM PRINT_QUEEN.
          PERFORM SET_COLLISION USING I_COUNT K_COUNT 0.
          PERFORM SET_QUEEN USING I_COUNT -1.
        ELSE.
          EXIT.
        ENDIF.
      ENDIF.
      K_COUNT = K_COUNT + 1.
     ENDWHILE.
     " THE lookback
     IF K_COUNT = COUNT + 1.
        PERFORM SET_QUEEN USING I_COUNT -1.
        I_COUNT = I_COUNT - 2.
     ENDIF.
     " THE EXIT OF THE WHOLE
     IF I_COUNT < 0.
       EXIT.
     ENDIF.

     " NEXT ROW.
     I_COUNT = I_COUNT + 1.

    ENDWHILE.
ENDFORM. " END OF THE CORE PROCESS

" SET THE POSITION OF THE QUEEN
FORM SET_QUEEN USING I_COUNT J_COUNT.
    READ TABLE I_QUEEN INDEX I_COUNT.
    I_QUEEN-ROW = J_COUNT.
    MODIFY I_QUEEN INDEX I_COUNT.
ENDFORM. " END OF THE SET POSITION

"CHECK WHERE THE POSITION(I,J) HAVE COLLISION.
FORM COLLISION USING I_COUNT J_COUNT.
    READ TABLE I_COLUM INDEX J_COUNT .
    READ TABLE I_LEFT INDEX  I_COUNT - J_COUNT + COUNT.
    READ TABLE I_RIGHT INDEX I_COUNT + J_COUNT .
    " IF ALL THE POSTION IS NOT COLISSION WITH OTHERS, THEN CHANGE THE STATUS OF THE POSTION, AND CALL THE PROCESS_QUEEN FOR THE NEXT ROW PROCESSING.
    IF I_COLUM-VAL = 0 AND I_LEFT-VAL = 0 AND I_RIGHT-VAL = 0.
      I_COLLISION = 0.
    ELSE.
      I_COLLISION = 1.
    ENDIF.

ENDFORM. " END OF THE CHECK COLLISION

" SET THE POSITION(I,J) WITH I_COLLI.
FORM SET_COLLISION USING I_COUNT1 J_COUNT1 I_COLLI1.
  IF I_COLLI1 = 0. " SET ALL THE RELATE (I,J) POSITION WITH COLLISION FALSE
      READ TABLE I_COLUM INDEX J_COUNT1 .
      READ TABLE I_LEFT INDEX I_COUNT1 - J_COUNT1 + COUNT.
      READ TABLE I_RIGHT INDEX J_COUNT1 + I_COUNT1 .
      I_COLUM-VAL = 0 .
      MODIFY I_COLUM INDEX J_COUNT1 .
      I_LEFT-VAL = 0.
      MODIFY I_LEFT INDEX I_COUNT1 - J_COUNT1 + COUNT .
      I_RIGHT-VAL = 0.
      MODIFY I_RIGHT INDEX J_COUNT1 + I_COUNT1 .
  ELSE. " SET ALL THE RELATE (I,J) POSITION WITH COLLISION TRUE
      READ TABLE I_COLUM INDEX J_COUNT1 .
      READ TABLE I_LEFT INDEX I_COUNT1 - J_COUNT1 + COUNT.
      READ TABLE I_RIGHT INDEX J_COUNT1 + I_COUNT1 .
      I_COLUM-VAL = 1 .
      MODIFY I_COLUM INDEX J_COUNT1 .
      I_LEFT-VAL = 1.
      MODIFY I_LEFT INDEX I_COUNT1 - J_COUNT1 + COUNT .
      I_RIGHT-VAL = 1.
      MODIFY I_RIGHT INDEX J_COUNT1 + I_COUNT1 .
  ENDIF.

ENDFORM. " END OF THE SET COLLISION

****the print FORM of the queen******
FORM PRINT_QUEEN.
  OK_TIMES = OK_TIMES + 1.
  DATA i_index type i.
  i_index = 1." ROW INDEX
      LOOP AT I_QUEEN .
        Data i_qu type i.
        i_qu = 1.
        WRITE: (2) i_index. " OUTPUT THE ROW NUM

        WHILE i_qu < I_QUEEN-ROW. " OUTPUT THE BLANK BEFORE THE QUEEN
          WRITE: '_ '.
          i_qu = i_qu + 1.
        ENDWHILE.

        WRITE: '* '. " THE QUEEN POSITION

        WHILE i_qu < COUNT." OUTPUT THE BLANK AFTER THE QUEEN
          WRITE: '_ '.
          i_qu = i_qu + 1.
        ENDWHILE.

        WRITE /.
        i_index = i_index + 1.
      ENDLOOP .
      WRITE /.
ENDFORM. " END OF THE PRINT.

*&---------------------------------------------------------------------*
*& Report  Z_N_QUEEN_BY_RECURSION
*&
*&---------------------------------------------------------------------*
*& FINISHED BY Seine Zhang AT 2009-09-10
*&
*&---------------------------------------------------------------------*

REPORT  Z_N_QUEEN_BY_RECURSION.
*** for show in the statusbar when processing
CALL FUNCTION 'SAPGUI_PROGRESS_INDICATOR'
EXPORTING
TEXT = 'The report is processing the queen problem, please wait for the result.'.

DATA: BEGIN OF ROW ,
  VAL TYPE I,
END OF ROW .
DATA: I_COLUM LIKE ROW OCCURS 0 WITH HEADER LINE . "COLUM OF THE COLISSION
DATA: I_LEFT  LIKE ROW OCCURS 0 WITH HEADER LINE . "LEFT DIAGONAL OF THE COLISSION
DATA: I_RIGHT LIKE ROW OCCURS 0 WITH HEADER LINE . "RIGHT DIAGONAL OF THE COLISSION
DATA:BEGIN OF queen,
    row TYPE I VALUE '0',
    END OF queen.
DATA: I_QUEEN LIKE QUEEN OCCURS 0 WITH HEADER LINE." QUEEN FOR PRINT.

DATA: OK_TIMES TYPE I VALUE '0'.

******GET THE COUNT OF THE QUEEN
SELECTION-SCREEN COMMENT /12(30) remark.
PARAMETERS: count TYPE I DEFAULT '8'.
INITIALIZATION.
  remark  = 'Please enter the count of queens'.
  count   = '8'.

******PROCESS THE QUEEN PROBLEM
START-OF-SELECTION.
  WRITE: /,'N QUEEN PROBLEM',/.
  IF COUNT > '0' AND COUNT < '20'." IF THE COUNT OF QUEEN IS MORE THAN 20, THE TIME MAYBE UNTOTERANBLE.
    WRITE: /, COUNT,/.
    PERFORM MAIN_PROCESS USING COUNT.
  ELSE.
    WRITE: /, 'WRONG COUNT'.
  ENDIF.

****THE MAIN PROCESS FUNCITON
FORM MAIN_PROCESS USING I_NUM.
************INITIALIZATION**********************
  "initial the queen array
  DO I_NUM TIMES .
    I_QUEEN-ROW = -1 .
    APPEND I_QUEEN .
  ENDDO.
  "initial the colum and left ,right diagonal
  "1-NUM
  DO I_NUM TIMES .
    I_COLUM-VAL = 0 .
    APPEND I_COLUM .
  ENDDO.
  "ROW-COLUM+NUM(1-2*NUM)
  DO I_NUM * 2 TIMES .
    I_LEFT-VAL = 0 .
    APPEND I_LEFT .
  ENDDO.
  "ROW+COLUM(1-2*NUM)
  DO I_NUM * 2 TIMES .
    I_RIGHT-VAL = 0 .
    APPEND I_RIGHT .
  ENDDO.
********END OF INITIALZATION*******************
  " OUTPUT THE COLUM FORMATE.
  DATA I_OUT TYPE I.
  I_OUT = 1.
  WRITE: ' |'.
  DO COUNT TIMES.
    WRITE (2) I_OUT.
    I_OUT = I_OUT + 1.
  ENDDO.
  WRITE: /.
  " END OF THE OUTPUT FORMATE.

  " CALL CORE THE PROCESSING
  PERFORM PROCESS_QUEEN USING 1.

  " OUTPUT THE TOTAL OF SOLUTIONL.
  WRITE: /, 'There are ',OK_TIMES, 'in all for the solution of ', COUNT,' queen problem'.

ENDFORM.   " END OF THE MAIN PROCESS

****the core queen process****
****I_COUNT MEANS PROCESSING THE I_COUNT ROW.
FORM PROCESS_QUEEN USING I_COUNT.
  DATA: I_GO TYPE I.
  I_GO = 1.
  WHILE I_GO <= COUNT.
    READ TABLE I_COLUM INDEX I_GO .
    READ TABLE I_LEFT INDEX I_COUNT - I_GO + COUNT.
    READ TABLE I_RIGHT INDEX I_GO + I_COUNT .
    " IF ALL THE POSTION IS NOT COLISSION WITH OTHERS, THEN CHANGE THE STATUS OF THE POSTION, AND CALL THE PROCESS_QUEEN FOR THE NEXT ROW PROCESSING.
    IF I_COLUM-VAL = 0 AND I_LEFT-VAL = 0 AND I_RIGHT-VAL = 0.
      "WRITE I_COLUM-VAL.
      I_COLUM-VAL = 1 .
      MODIFY I_COLUM INDEX I_GO .
      I_LEFT-VAL = 1.
      MODIFY I_LEFT INDEX I_COUNT - I_GO + COUNT .
      I_RIGHT-VAL = 1.
      MODIFY I_RIGHT INDEX I_GO + I_COUNT .
      "CHANGE THE VALUE OF THE QUEEN.
      READ TABLE I_QUEEN INDEX I_COUNT.
      I_QUEEN-ROW = I_GO.
      MODIFY I_QUEEN INDEX I_COUNT.
      " check whether the solution has been get,if yes, print out.
      " else call the next row process_queen proecessing.
      IF I_COUNT < COUNT." IF THE ROW IS NOT THE LAST ROW, PROCESS NEXT ROW, ELSE PRINT OUT.
        DATA: I_NEXT TYPE I.
        I_NEXT = I_COUNT + 1.
        PERFORM PROCESS_QUEEN USING I_NEXT.
      ELSE.
        PERFORM PRINT_QUEEN.
      ENDIF.

      "return to the value before, to get more solution.
      READ TABLE I_COLUM INDEX I_GO .
      READ TABLE I_LEFT INDEX I_COUNT - I_GO + COUNT.
      READ TABLE I_RIGHT INDEX I_GO + I_COUNT .
      I_COLUM-VAL = 0 .
      MODIFY I_COLUM INDEX I_GO .
      I_LEFT-VAL = 0.
      MODIFY I_LEFT INDEX I_COUNT - I_GO + COUNT .
      I_RIGHT-VAL = 0.
      MODIFY I_RIGHT INDEX I_GO + I_COUNT .

    ENDIF.
    I_GO = I_GO + 1.
  ENDWHILE.
ENDFORM. " END OF THE CORE PROCESS

****the print FORM of the queen******
FORM PRINT_QUEEN.
  OK_TIMES = OK_TIMES + 1.
  DATA i_index type i.
  i_index = 1." ROW INDEX
      LOOP AT I_QUEEN .
        Data i_qu type i.
        i_qu = 1.
        WRITE: (2)i_index." OUTPUT THE ROW NUM

        WHILE i_qu < I_QUEEN-ROW. " OUTPUT THE BLANK BEFORE THE QUEEN
          WRITE: '_ '.
          i_qu = i_qu + 1.
        ENDWHILE.

        WRITE: '* '. " THE QUEEN POSITION

        WHILE i_qu < COUNT." OUTPUT THE BLANK AFTER THE QUEEN
          WRITE: '_ '.
          i_qu = i_qu + 1.
        ENDWHILE.

        WRITE /.
        i_index = i_index + 1.
      ENDLOOP .
      WRITE /.
ENDFORM. " END OF THE PRINT.

4月后开始突击项目，在5月底基本实现。

从5月底开始实习。

于是6月算是把自己的重心从实验室项目上逐渐转移，当然在必要时还得继续完善。

可是实习的每天都是来回每天4个多小时的车程，工作本来起始就有些很不顺畅，可是生活还是在煎熬中跌跌撞撞起伏。

而6月底ta也走了，留下我一个。

7月我搬到了同学住的地方，离公司很近，以至于我在已经负翁的情况还是买了辆车，骑车过去需要10-30分钟不等，今天下班那就是骑了30分钟回来的。

工作本身没有绝对的挑战，但要熟悉，可是就因为这样，觉得不甚满意，总觉得没有找到自己最想要的。也许是远离社会太久。

半年多来，烦恼过，适应过，又纠结过，可真正省心的却没有。

论文，工作，毕业，还有。。。。很多。

可现在只是夏天！也已经是闷闷的夏日。

很热！

傍晚回来看到天很雾蒙，就像身边很多事物一样！

但我知道该做什么！～！

清明前夕，出发去南京。仅在此记下此行的经过而已。

4.3日早上7点三刻起床，9点已经在958上了。犹记得上次群体去崇明挤申闵线(现为958)的情形(我是力排众议踏上申闵，后来被大家一再笔视)。这次算是提前到了车站，途中竟傻傻的走错出口，以致走了回头路，看来真是已不去火车站混多年了。

于是在火车晚点15分钟后于11点25出发，但是拍下的却是汽车站：

 

14点30分左右到了南京，尽管和期待的不一样吧。

看到了传说中的玄武湖，湖水挺脏的，尽管是活水：

然后还看到了古城墙，不过照片中的墙并没有现场看到的那种感觉，尽管这些城墙也有五六百年的历史或许，但可以很明显看到有修补的痕迹，印证了其实大凡实物都有老去的可能。

 沿着湖走，我们到了玄武湖一入口旁的玄武门。

然后一路上发现湖边有标志路程的标牌，后来看到是所谓的锻炼路程标志，就是从玄武门开始，总共是9000多米。不过貌似去的日子不是最好的，因为总感觉天气雾蒙蒙的，尽管我们也算lucky，因为天气预报是阵雨。可是阵雨是到旁晚才来的，而且是只有那么一会，以至于伞还没撑开雨就停了。

城墙下的hilda，哈哈，这张还挺有感觉的。

 

然后在玄武湖旁边的闸口旁

绕着玄武湖古城墙走，我们去了解放门旁边的鸡鸣寺。可是没拍照，想想觉得在佛教之地还是别乱来。

出了鸡鸣寺，已经大概接近傍晚了，起了风，把樱花(我很花痴的就把它们认为是樱花了，具体是什么不考证了，呵呵)扬起，不过破手机没能拍下那种效果

在接下来走在北京东路上时，下了所谓的阵雨，在等红绿灯的时候，被此路牌小雷一下。另外南京的红绿灯居然有100多秒的。。。

到总统府的时候，已经关门了，只能在外面瞅瞅，不过看了国民时期放旗帜的旗杆，尽管青天白日已经不再。

实验室徐同学说上次去南京顿顿吃老鸭粉丝，于是在路上看到一家老鸭粉丝时就憋不住了，期待了很久，发现依然感觉不错，而且6块一碗，跟学校价格一样，据说比学校的好吃n多。。。。

去旅馆把住的地方定了后，然后就出发去了夫子庙。

在夫子庙转了好久才找到，此时真好夜景，所以算是不是的时间安排，此归功于此行的planer，呵呵。。。（拍夜景的时候发现这破手机真不行了）

然后再瞎逛8逛中居然找到了乌衣巷，

还看到了老王，呵呵

后来发现这才是夫子庙的中心：

这一周围东西很多，特别是晚上很有感觉。

然后到处逛逛打车回了旅馆，10点过回旅馆。

第二天早饭后出发去紫金山。发现昨晚应该大雨，心想这样爬山空气肯定很不错

因为第一天走的太多，都还没返过神来，坐车时晕晕的。

坐95路到了太平门。刚下车发现下雨了，于是在雨中走路到了紫金山脚下，本想爬山到天文台，然后坐索道，岂知票价照样，所以决定坐上去，最后走下来。

坐索道的时候正下着雨，所以从上面看下午外面都笼罩在雾中。

到索道中间站的时候下来走路去了旁边的天文台，但是没进去，因为这种天气估计就只有空工具了。并且本告知，学生7折票，但是研究生不算，看来我们都老了，毕竟都被排除在学生行列了。

原路还回继续索道，这时候看下面的景色又些许不同，而且鱼也停了。

最后到了头陀岭。

从头陀岭下来，走了很长的山路，发现要走山路穿登山鞋的效果是相当明显的，至少现在脚基本好了。下来旁边有中山陵，孙中山纪念馆，明孝陵等，话说这一天正好是清明节，貌似去此类的人还是相当不少的。

从紫金山下来后，我们坐公交到了明故宫，虽然很累了，但发现此时回去又太早，但是晚饭总归要解决的，于是想找个地方解决，突然发现南大离这也不远，于是在地图上早，惊奇发现居然有公交去南大旁边的钟楼，于是坐上了游3，到了钟楼，随便逛悠了一下

然后问路人找到了去南大的路，

最后顺便在南大把晚饭解决了，然后被雷了一把，居然南大校外人员就餐加收40%的，心想我们学校的10%已经很雷，居然还有更雷的。不过发现不同的是，南大的食堂真以学生为本，至少他们可以在证明是本校学生时不用加收费用，此举却未在我们这体现。可是就算加收这么多，我们一共要了6个菜，全荤，而且还大荤(在我们学校应该叫大大荤了。。。)的那种，加上加收的40%一共16块。我们是边吃边感觉，这就是世道啊。。。

然后转悠转悠，都5点40点菜出发往回走，去坐地铁到火车站。最后在大雨中于8点半回到了上海。此行的planer下车后的第一句话：我知道上海和南京的区别了，在上海一个人实在太渺小，因为整个世界都是建筑和人，而南京看过去的绿化总是不少。

 

此行给我的感受就是，一个城市的历史沉淀其实是可以在每个细节中体现。

最后，感谢此行我们伟大的planer-hilda。。。。

 

 

 

 

ZT,备用。

对于Join操作中的Where子句,正是因为对历史的兼容性造成了一些误解.
从SQL 92标准以后,Join语法规范中并不包含Where子句.
对于外联结来说,Where只是提供Join操作结果集上的过滤或者说是搜索.

对于outer join来说,良好的书写习惯是:
用on子句说明联结条件,用Where子句来说明search条件.
如果把search条件放到了on子句中,会出现意想不到的结果,看下例:
    table_A.a          table_A.b                             table_B.a
        3                        1                               3
        6                        6                               6

(1) SELECT *
     FROM table_A
     LEFT OUTER JOIN table_B ON  (table_A.a = table_B.a)
     WHERE table_A.b >5;
结果是:   
      table_A.a          table_A.b                             table_B.a
          6                      6                                6
         
(2) SELECT *
     FROM table_A
     LEFT OUTER JOIN table_B ON  (table_A.a = table_B.a)
     AND (table_A.b >5);
结果是几条记录呢? 2条! 如下:
    table_A.a          table_A.b                             table_B.a
        3                        1                               null
        6                        6                                6

是不是有些奇怪,和想要的结果有些出入?

如果把table_A中(6,6)的记录修改为(6,3),再执行语句2,又得到什么结果呢?
答案还是2条记录. 具体是什么,可以自己执行一下看看.
之所以会有这样的结果,会在后面进行解释.

在进一步探讨on,where子句之前,我先引入如下概念
由于A left join B和B right join A的等效性,在很多时候说左表和右表就比较容易
混淆了.所以在一些资料中, 会使用Inner table(内表)和Outer Table(外表)来区分
Inner Table:内表就是只提供匹配记录信息的表;
Outer Table:外表是指对外联结同时提供未匹配记录信息的表.
对于inner join来说,参与join的表都是内表;
对于A  left outer join B来说, A就是外表,B就是内表.
我个人也觉得这样来定义能够更好的表达后面的论述,所以下面也就用
Inner table和Outer table来说明.

对于outer join来说,遵循如下规律:
<1>对于外联结,一般来说,结果集合的记录数是由Outer table来决定的;

<2>对于Outer table的过滤条件,必须放在where子句中才能生效.
       在where子句中对Outer table进行过滤后,再进行join操作.

<3>如果把Outer table的过滤条件放到On子句中,并不会影响到结果集中的
      记录数.它所能影响的只是在结果集中的记录中,哪些记录对应的inner table
      的信息会以null形式出现.
      再看一下例句2的返回结果.它的意思就是对于join操作的结果,
      其中table_A.b<=5的记录,其table_B.a都是null.
      同理,把table_A中(6,6)的记录修改为(6,3),所得到的结果所有table_B.a
      都显示成了null...

<4>在Where条件中如果对Inner Table进行过滤操作,
       那么虽然在SQL语句中出现了left/right/full outer join的关键词,但实际上
       的实现方式是内联结,优化器会以inner join方式实现!
      原因:因为内表只提供匹配记录信息,对于这些信息进行过滤,最终的操作
              与inner join等效;
             
      (3) SELECT *
     FROM table_A
     LEFT OUTER JOIN table_B ON  (table_A.a = table_B.a)
     WHERE  table_B.a > 3;
     可以用数据库对该语句和inner join的方式的执行计划比较一下,是否相同.
    
<5>把Inner table的过滤条件放到On子句中,相当于对Inner table先进行过滤
       Outer table和过滤后的inner table子集进行join操作.
 
综上,在outer join操作中,如果想进行过滤操作,
对于Outer table,放在where子句中,
对于Inner table,放在On子句中;

把Inner table的过滤操作放在Where子句中,转化称为内联结,
把Outer table的过滤操作放在On子句中,只是让不满足过滤条件的记录,
其相应的关联字段取值为null.
             
清楚了以上几种情况,相信再复杂的关联查询理解起来也不是什么难事了.
至于self join,可以通过alias name方式视同两个结构一样的表,然后进行
相应的join操作了. 实际的应用中多是用来把纵表拉成横表的应用,
这里就不再多说了.

基本上能想到的Join语法里面应该注意的东西就是这几篇随笔里面
所提到的.希望对大家能够有所帮助.

有些事，我们明知道是错的，也要坚持，因为不甘心；有些人，我们明知道是爱的，也要放弃，因为没有结局；有些love，我们明知道是没有的，也要___，因为___
就像lover最后会因为是一个人的love而over，因为那是1+over. 而一切的forever,都变成了for ever.
也许还在不断念叨没有u的trust，难道真是believe中间藏着的那个lie么？
但是自己还是很期待有u的understanding...
如果说，没有心安而做的事是冲动，那么理得之时反觉得是自己的错过。可是在fault中间却只发现了u，迷失了自己。
难道这真是没有为什么，只有属于自己的是什么吗？

   很久就想写这篇日志了。只是感觉总是缺点什么，时间，心情，精力，正所谓天时地利，人和方为可行。

   9月的自己过得有点不知所谓，那么9月前的自己过得就所谓不知了。因为自己给了自己很多无所谓， 而得到的却是更多的无所谓。从9月的开始，陪自己过得有篮球---一个曾今不以为然的运动项目。可是在这接下来的20天中，在那一片空旷的橡胶场地上，在晚上8，9点後，有一个身影在学会自娱自乐。如果要说，自己得到了什么，那就是让自己知道：什么都是可以改变的，别人说什么都不重要的，关键是自己对自己说什么做什么。还有就是，当一个人决定做什么了，就会不回头的做下去，就算最后无法真正达到目的，但是这其中的过程无非是足以珍贵和罕稀的。就像小时候做数学题，一步步按照自己的思路演算下去，就算结果错了，也能得到自己计算能力的成长。生活其实更是如此。打球亦是如此，酣畅淋漓的之后，身体累疲了，那么就可以不去想那些烦人的事，随着时间流逝，该抹去的都会消失殆尽的。。。有人说我是一个爱感叹生活的人，其实，自己又何尝希望呢？就像以前那些常爱以文讽世的离骚之人，为何会如此说时事的不堪，那还得从他们的郁郁不得志说起吧。当然自己就算不上得不得志了，因为毕竟是不同的境遇。

   过去让我自己明白了，自己能给什么，和自己想要什么。

   如果说9月的自己是活在另一个世界中，那么10月的自己应该活在现实中。当然在那日子里要真诚感谢让自己不至于空寂的大好人h。10这个数字在中文中有其含义。一横一竖，同样10也是由最小的正整数组成。所以往往最简单的事物可以组建和形成的东西都是可以很不可思议的。所以在10里，与其自己寂寂落落的感叹人生，倒不如让everything×10。在炎夏逝去时，气爽金秋有的自有其独到神韵让苍宇所倾倒。而寒寒气流的到来更是让自我沉静的独方妙灵。就像今天的数字一样1001，是那么无暇完美。有的都是最简洁，有的都是最直接，有的都是最后和最开始。

   live happily ever after. 不让别人受伤，也不让自己。

计划往往赶不及变化。

如果说忙碌和疲劳可以使人不无聊的话，

那么重点太多可能会让人没有方向。

就像选择有时候并不存在，仅仅因为缘分。

忙碌了一个星期，如果要说收获的话，

那么应当包括：

经历8点三刻的二号线和5点三刻人民广场换乘通道；

连续几天6点过起床，8点到家；

研究Code的功力还是有的；

多样事情的所谓并发操作；

还有就是知道了自己想要什么；

而更为具体的是我知道了接下来要做什么，可笑的是这也是计划，

项目，论文，日语，回家。

那么最为直接的可能就是这篇百无聊赖难得的日志吧。