有时， 为了让应用程序运行得更快，所做的全部工作就是在这里或那里做一些很小调整。啊，但关键在于确定如何进行调整！迟早您会遇到这种情况：应用程序中的 SQL 查询不能按照您想要的方式进行响应。它要么不返回数据，要么耗费的时间长得出奇。如果它降低了报告或您的企业应用程序的速度，用户必须等待的时间过长，他 们就会很不满意。就像您的父母不想听您解释为什么在深更半夜才回来一样，用户也不会听你解释为什么查询耗费这么长时间。（“对不起，妈妈，我使用了太多的 LEFT JOIN。”）用户希望应用程序响应迅速，他们的报告能够在瞬间之内返回分析数据。就我自己而言，如果在 Web 上冲浪时某个页面要耗费十多秒才能加载（好吧，五秒更实际一些），我也会很不耐烦。

为了解决这些问题，重要的是找到问题的根源。那么，从哪里开始呢？根本原因通常在于数据库设计和访问它的查询。在本月的专栏中，我将讲述四项技术， 这些技术可用于提高基于 SQL Server? 的应用程序的性能或改善其可伸缩性。我将仔细说明 LEFT JOIN、CROSS JOIN 的使用以及 IDENTITY 值的检索。请记住，根本没有神奇的解决方案。调整您的数据库及其查询需要占用时间、进行分析，还需要大量的测试。这些技术都已被证明行之有效，但对您的应 用程序而言，可能其中一些技术比另一些技术更适用。

从 INSERT 返回 IDENTITY

我决定从遇到许多问题的内容入手：如何在执行 SQL INSERT 后检索 IDENTITY 值。通常，问题不在于如何编写检索值的查询，而在于在哪里以及何时进行检索。在 SQL Server 中，下面的语句可用于检索由最新在活动数据库连接上运行的 SQL 语句所创建的 IDENTITY 值：

SELECT @@IDENTITY

这个 SQL 语句并不复杂，但需要记住的一点是：如果这个最新的 SQL 语句不是 INSERT，或者您针对非 INSERT SQL 的其他连接运行了此 SQL，则不会获得期望的值。您必须运行下列代码才能检索紧跟在 INSERT SQL 之后且位于同一连接上的 IDENTITY，如下所示：

INSERT INTO Products (ProductName) VALUES ('Chalk')
SELECT @@IDENTITY

在一个连接上针对 Northwind 数据库运行这些查询将返回一个名称为 Chalk 的新产品的 IDENTITY 值。所以，在使用 ADO 的 Visual Basic? 应用程序中，可以运行以下语句：

Set oRs = oCn.Execute("SET NOCOUNT ON;INSERT INTO Products _
(ProductName) VALUES ('Chalk');SELECT @@IDENTITY")
lProductID = oRs(0)

此代码告诉 SQL Server 不要返回查询的行计数，然后执行 INSERT 语句，并返回刚刚为这个新行创建的 IDENTITY 值。SET NOCOUNT ON 语句表示返回的记录集有一行和一列，其中包含了这个新的 IDENTITY 值。如果没有此语句，则会首先返回一个空的记录集（因为 INSERT 语句不返回任何数据），然后会返回第二个记录集，第二个记录集中包含 IDENTITY 值。这可能有些令人困惑，尤其是因为您从来就没有希望过 INSERT 会返回记录集。之所以会发生此情况，是因为 SQL Server 看到了这个行计数（即一行受到影响）并将其解释为表示一个记录集。因此，真正的数据被推回到了第二个记录集。当然您可以使用 ADO 中的 NextRecordset 方法获取此第二个记录集，但如果总能够首先返回该记录集且只返回该记录集，则会更方便，也更有效率。

此方法虽然有效，但需要在 SQL 语句中额外添加一些代码。获得相同结果的另一方法是在 INSERT 之前使用 SET NOCOUNT ON 语句，并将 SELECT @@IDENTITY 语句放在表中的 FOR INSERT 触发器中，如下面的代码片段所示。这样，任何进入该表的 INSERT 语句都将自动返回 IDENTITY 值。

CREATE TRIGGER trProducts_Insert ON Products FOR INSERT AS 
    SELECT @@IDENTITY 
GO

触发器只在 Products 表上发生 INSERT 时启动，所以它总是会在成功 INSERT 之后返回一个 IDENTITY。使用此技术，您可以始终以相同的方式在应用程序中检索 IDENTITY 值。

内嵌视图与临时表

某些时候，查询需要将数据与其他一些可能只能通过执行 GROUP BY 然后执行标准查询才能收集的数据进行联接。例如，如果要查询最新五个定单的有关信息，您首先需要知道是哪些定单。这可以使用返回定单 ID 的 SQL 查询来检索。此数据就会存储在临时表（这是一个常用技术）中，然后与 Products 表进行联接，以返回这些定单售出的产品数量：

CREATE TABLE #Temp1 (OrderID INT NOT NULL, _
                     OrderDate DATETIME NOT NULL)
INSERT INTO #Temp1 (OrderID, OrderDate)
SELECT     TOP 5 o.OrderID, o.OrderDate
FROM Orders o ORDER BY o.OrderDate DESC
SELECT     p.ProductName, SUM(od.Quantity) AS ProductQuantity
FROM     #Temp1 t 
    INNER JOIN [Order Details] od ON t.OrderID = od.OrderID
    INNER JOIN Products p ON od.ProductID = p.ProductID 
GROUP BY p.ProductName
ORDER BY p.ProductName
DROP TABLE #Temp1

这些 SQL 语句会创建一个临时表，将数据插入该表中，将其他数据与该表进行联接，然后除去该临时表。这会导致此查询进行大量 I/O 操作，因此，可以重新编写查询，使用内嵌视图取代临时表。内嵌视图只是一个可以联接到 FROM 子句中的查询。所以，您不用在 tempdb 中的临时表上耗费大量 I/O 和磁盘访问，而可以使用内嵌视图得到同样的结果：

SELECT p.ProductName, 
    SUM(od.Quantity) AS ProductQuantity
FROM     (
    SELECT TOP 5 o.OrderID, o.OrderDate
    FROM     Orders o 
    ORDER BY o.OrderDate DESC
    ) t 
    INNER JOIN [Order Details] od ON t.OrderID = od.OrderID
    INNER JOIN Products p ON od.ProductID = p.ProductID 
GROUP BY
    p.ProductName
ORDER BY
    p.ProductName

此查询不仅比前面的查询效率更高，而且长度更短。临时表会消耗大量资源。如果只需要将数据联接到其他查询，则可以试试使用内嵌视图，以节省资源。

避免 LEFT JOIN 和 NULL

当然，有很多时候您需要执行 LEFT JOIN 和使用 NULL 值。但是，它们并不适用于所有情况。改变 SQL 查询的构建方式可能会产生将一个花几分钟运行的报告缩短到只花几秒钟这样的天壤之别的效果。有时，必须在查询中调整数据的形态，使之适应应用程序所要求的 显示方式。虽然 TABLE 数据类型会减少大量占用资源的情况，但在查询中还有许多区域可以进行优化。SQL 的一个有价值的常用功能是 LEFT JOIN。它可以用于检索第一个表中的所有行、第二个表中所有匹配的行、以及第二个表中与第一个表不匹配的所有行。例如，如果希望返回每个客户及其定单， 使用 LEFT JOIN 则可以显示有定单和没有定单的客户。

此工具可能会被过度使用。LEFT JOIN 消耗的资源非常之多，因为它们包含与 NULL（不存在）数据匹配的数据。在某些情况下，这是不可避免的，但是代价可能非常高。LEFT JOIN 比 INNER JOIN 消耗资源更多，所以如果您可以重新编写查询以使得该查询不使用任何 LEFT JOIN，则会得到非常可观的回报（请参阅图 1 中的图）。

图 1 查询

加快使用 LEFT JOIN 的查询速度的一项技术涉及创建一个 TABLE 数据类型，插入第一个表（LEFT JOIN 左侧的表）中的所有行，然后使用第二个表中的值更新 TABLE 数据类型。此技术是一个两步的过程，但与标准的 LEFT JOIN 相比，可以节省大量时间。一个很好的规则是尝试各种不同的技术并记录每种技术所需的时间，直到获得用于您的应用程序的执行性能最佳的查询。

测试查询的速度时，有必要多次运行此查询，然后取一个平均值。因为查询（或存储过程）可能会存储在 SQL Server 内存中的过程缓存中，因此第一次尝试耗费的时间好像稍长一些，而所有后续尝试耗费的时间都较短。另外，运行您的查询时，可能正在针对相同的表运行其他查 询。当其他查询锁定和解锁这些表时，可能会导致您的查询要排队等待。例如，如果您进行查询时某人正在更新此表中的数据，则在更新提交时您的查询可能需要耗 费更长时间来执行。

避免使用 LEFT JOIN 时速度降低的最简单方法是尽可能多地围绕它们设计数据库。例如，假设某一产品可能具有类别也可能没有类别。如果 Products 表存储了其类别的 ID，而没有用于某个特定产品的类别，则您可以在字段中存储 NULL 值。然后您必须执行 LEFT JOIN 来获取所有产品及其类别。您可以创建一个值为“No Category”的类别，从而指定外键关系不允许 NULL 值。通过执行上述操作，现在您就可以使用 INNER JOIN 检索所有产品及其类别了。虽然这看起来好像是一个带有多余数据的变通方法，但可能是一个很有价值的技术，因为它可以消除 SQL 批处理语句中消耗资源较多的 LEFT JOIN。在数据库中全部使用此概念可以为您节省大量的处理时间。请记住，对于您的用户而言，即使几秒钟的时间也非常重要，因为当您有许多用户正在访问同 一个联机数据库应用程序时，这几秒钟实际上的意义会非常重大。

灵活使用笛卡尔乘积

对于此技巧，我将进行非常详细的介绍，并提倡在某些情况下使用笛卡尔乘积。出于某些原因，笛卡尔乘积 (CROSS JOIN) 遭到了很多谴责，开发人员通常会被警告根本就不要使用它们。在许多情况下，它们消耗的资源太多，从而无法高效使用。但是像 SQL 中的任何工具一样，如果正确使用，它们也会很有价值。例如，如果您想运行一个返回每月数据（即使某一特定月份客户没有定单也要返回）的查询，您就可以很方 便地使用笛卡尔乘积。 图 2 中的 SQL 就执行了上述操作。

虽然这看起来好像没什么神奇的，但是请考虑一下，如果您从客户到定单（这些定单按月份进行分组并对销售额进行小计）进行了标准的 INNER JOIN，则只会获得客户有定单的月份。因此，对于客户未订购任何产品的月份，您不会获得 0 值。如果您想为每个客户都绘制一个图，以显示每个月和该月销售额，则可能希望此图包括月销售额为 0 的月份，以便直观标识出这些月份。如果使用 图 2 中的 SQL，数据则会跳过销售额为 0 美元的月份，因为在定单表中对于零销售额不会包含任何行（假设您只存储发生的事件）。

图 3 中 的代码虽然较长，但是可以达到获取所有销售数据（甚至包括没有销售额的月份）的目标。首先，它会提取去年所有月份的列表，然后将它们放入第一个 TABLE 数据类型表 (@tblMonths) 中。下一步，此代码会获取在该时间段内有销售额的所有客户公司的名称列表，然后将它们放入另一个 TABLE 数据类型表 (@tblCus-tomers) 中。这两个表存储了创建结果集所必需的所有基本数据，但实际销售数量除外。 第一个表中列出了所有月份（12 行），第二个表中列出了这个时间段内有销售额的所有客户（对于我是 81 个）。并非每个客户在过去 12 个月中的每个月都购买了产品，所以，执行 INNER JOIN 或 LEFT JOIN 不会返回每个月的每个客户。这些操作只会返回购买产品的客户和月份。

笛卡尔乘积则可以返回所有月份的所有客户。笛卡尔乘积基本上是将第一个表与第二个表相乘，生成一个行集合，其中包含第一个表中的行数与第二个表中的 行数相乘的结果。因此，笛卡尔乘积会向表 @tblFinal 返回 972 行。最后的步骤是使用此日期范围内每个客户的月销售额总计更新 @tblFinal 表，以及选择最终的行集。

如果由于笛卡尔乘积占用的资源可能会很多，而不需要真正的笛卡尔乘积，则可以谨慎地使用 CROSS JOIN。例如，如果对产品和类别执行了 CROSS JOIN，然后使用 WHERE 子句、DISTINCT 或 GROUP BY 来筛选出大多数行，那么使用 INNER JOIN 会获得同样的结果，而且效率高得多。如果需要为所有的可能性都返回数据（例如在您希望使用每月销售日期填充一个图表时），则笛卡尔乘积可能会非常有帮助。 但是，您不应该将它们用于其他用途，因为在大多数方案中 INNER JOIN 的效率要高得多。

拾遗补零

这里介绍其他一些可帮助提高 SQL 查询效率的常用技术。假设您将按区域对所有销售人员进行分组并将他们的销售额进行小计，但是您只想要那些数据库中标记为处于活动状态的销售人员。您可以按 区域对销售人员分组，并使用 HAVING 子句消除那些未处于活动状态的销售人员，也可以在 WHERE 子句中执行此操作。在 WHERE 子句中执行此操作会减少需要分组的行数，所以比在 HAVING 子句中执行此操作效率更高。HAVING 子句中基于行的条件的筛选会强制查询对那些在 WHERE 子句中会被去除的数据进行分组。

另一个提高效率的技巧是使用 DISTINCT 关键字查找数据行的单独报表，来代替使用 GROUP BY 子句。在这种情况下，使用 DISTINCT 关键字的 SQL 效率更高。请在需要计算聚合函数（SUM、COUNT、MAX 等）的情况下再使用 GROUP BY。另外，如果您的查询总是自己返回一个唯一的行，则不要使用 DISTINCT 关键字。在这种情况下，DISTINCT 关键字只会增加系统开销。

您已经看到了，有大量技术都可用于优化查询和实现特定的业务规则，技巧就是进行一些尝试，然后比较它们的性能。最重要的是要测试、测试、再测试。在 此专栏的将来各期内容中，我将继续深入讲述 SQL Server 概念，包括数据库设计、好的索引实践以及 SQL Server 安全范例。

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

运用自连接同子查询之间有什么区别？请大家给点意见

SELECT R1.readerid,R1.readername,R1.unit,R1.bookcount
FROM ReaderInfo AS R1,ReaderInfo AS R2
WHERE R2.readerid=9704
AND R1.bookcount>R2.bookcount     --连接关系
ORDER BY R1.bookcount

SELECT readerid,readername,unit,bookcount
FROM ReaderInfo
WHERE bookcount>(SELECT bookcount   --使用子查询
FROM ReaderInfo
WHERE readerid=9704)
ORDER BY bookcount

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

MYSQL常用命令:

服务器：

1. 启动mysql服务

    > cd mysql-5.0/bin
    > mysqld --console --verbose

2. 停止mysql服务

    > mysqladmin -u root shutdown

客户端：

1. 客户端连接至mysql

    > mysql -h localhost -u root -p

2. 显示当前所有数据库

    > show databases;

3. 创建数据库

    > create database test;

4. 删除数据库

    > drop database test;

5. 切换数据库

    > use test;

6. 显示当前数据库中的所有表

    > show tables;

7. 显示某张表的结构信息

    > desc t_some_table; 

8. 客户端推出

    > exit; 

用户：

1. 查询所有用户

    > select host, user from mysql.user;

2. 创建用户（用户名：test；密码：test）

    > create user test identified by 'test'; 

3. 赋予用户权限

    > grant all privileges on test.* to 'test'@'%' ; 

4. 删除用户

    > drop user test; 

备份与恢复：

1. 备份数据库（后面不能加分号";"，否则会报error 1049）

    > mysqldump -u root -p test>d:/test_backup.sql

2. 恢复数据库

    > mysql -uroot -p test< d:/test_backup.sql;  

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

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

Generate a table with number sequence in sql
=========

1 Pre-defined collection types in Oracle
---------

select to_number(column_value) as num from
   table(sys.dbms_debug_vc2coll(1,2,3,4,5,6,7,8,9));

select to_number(column_value) as num from
   table(sys.KU$_VCNT(1,2,3,4,5,6,7,8,9));

select column_value as num from
   table(sys.KU$_OBJNUMSET(1,2,3,4,5,6,7,8,9));

2 Join: pure sql
---------

select a.i+b.i+c.i+d.i+1 as num
from
   (select 0 i from dual union all select 1 from dual) a,
   (select 0 i from dual union all select 2 from dual) b,
   (select 0 i from dual union all select 4 from dual) c,
   (select 0 i from dual union all select 8 from dual) d
order by num;

3 How to make number dynamic?
---------
?

3.1 Define function with collection type as return value

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

It's not only sql.

And myaybe it's not correct or appropriate for dynamic.

However, I like it.

First, define a type:

create or replace type T_NUM_TAB as TABLE OF NUMBER;

Then, define the function:

CREATE OR REPLACE FUNCTION NUM_COLLECT (
       NUM_START IN NUMBER, 
       NUM_END IN NUMBER,
       NUM_STEP IN NUMBER DEFAULT 1)
  RETURN T_NUM_TAB
AS
  l_tab   T_NUM_TAB := T_NUM_TAB();
  l_idx   NUMBER;
BEGIN
  l_idx := NUM_START;
  WHILE l_idx <= NUM_END LOOP
    l_tab.extend;
    l_tab(l_tab.last) := l_idx;
    l_idx := l_idx + NUM_STEP;
  END LOOP;

  RETURN l_tab;
END;

Now, use it as follows:

SQL> select * from table(num_collect(2,10,2));

COLUMN_VALUE
------------
           2
           4
           6
           8
          10

 Is it a good idea to take sql string as parameter for the function?

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

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

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

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

http://www.oracle.com/technology/oramag/code/tips2004/050304.html

1. create a function to concatenate strings.

CREATE OR REPLACE FUNCTION rowtocol( 
       p_slct IN VARCHAR2,
       p_dlmtr IN VARCHAR2 DEFAULT ',' 
) RETURN VARCHAR2 

  AUTHID CURRENT_USER AS

TYPE c_refcur IS REF CURSOR;

     lc_str VARCHAR2(4000);
     lc_colval VARCHAR2(4000);
     c_dummy c_refcur;

     BEGIN

     OPEN c_dummy FOR p_slct;
     LOOP
       FETCH c_dummy INTO lc_colval;
       EXIT WHEN c_dummy%NOTFOUND;
       lc_str := lc_str || p_dlmtr || lc_colval;
     END LOOP;

     CLOSE c_dummy;
     RETURN SUBSTR(lc_str,2);

     /* 
     EXCEPTION 
     WHEN OTHERS THEN
       lc_str := SQLERRM;
  
       IF c_dummy%ISOPEN THEN
          CLOSE c_dummy;
       END IF;
  
       RETURN lc_str;
     */
    END;

 Usage :

select distinct t.author, 
          rowtocol('select book from table_name where author=''' || t.author|| '''')
from table_name t
;

 or

select t.author, rowtocol('select book from table_name where author=''' || t.author|| '''', '#')
from table_name t
group by t.author
;

cons: less natural than user-defined aggregate function 

pros: more flexible, aggregate function could take only one parameter

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

Author    Book                     Author    Books
--------+--------                     --------+--------
poly    |   A                          poly   |   A,B,C
poly    |   B                          amy    |   D,E
poly    |   C         ====>
amy     |   D
amy     |   E

HOW?

select author, to_list(book) as books
  from table_name
group by author;

SO SIMPLE? 

Yes, we just need to create a user-defined aggregate function as follows:

1. create type object

create or replace 
type tolist as object 
( 
  list varchar2(2000), 

  static function ODCIAggregateInitialize 
  ( actx in out tolist 
  ) return number, 

  member function ODCIAggregateIterate 
  ( self  in out tolist , 
    value in varchar2 
  ) return number, 

  member function ODCIAggregateTerminate 
  ( self in tolist , 
    returnValue  out varchar2, 
    flags in varchar2 
  ) return number, 

  member function ODCIAggregateMerge 
  (self in out tolist , 
   ctx2 in     tolist  
  ) return number 
) 

 2. create type body

create or replace 
type body tolist is 

static function ODCIAggregateInitialize 
  ( actx in out tolist
  ) return number is 
  begin
    actx := tolist('');
    return ODCIConst.Success; 
  end; 


member function ODCIAggregateIterate 
  ( self  in out tolist, 
    value in varchar2
  ) return number is 
  begin 
        if self.list is null then self.list := value;
        else
           self.list := self.list || ',' || value; 
        end if;     
     return ODCIConst.Success; 
  end; 


 member function ODCIAggregateTerminate 
  ( self in tolist, 
    returnValue out varchar2, 
    flags in varchar2 
  ) return number is 
  begin 
   returnValue:= self.list; 
   return ODCIConst.Success; 
  end; 


  member function ODCIAggregateMerge 
  (self in out tolist, 
   ctx2 in     tolist 
  ) return number is 
  begin 
    if ctx2.list <> '' then 
       self.list := self.list || ',' || ctx2.list; 
    end if; 
    return ODCIConst.Success; 
  end; 

end; 

3. create function

CREATE OR REPLACE FUNCTION to_list
( x varchar2
) RETURN varchar2
PARALLEL_ENABLE
AGGREGATE USING tolist;

done

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

http://download-west.oracle.com/docs/cd/B10501_01/appdev.920/a96595/dci11agg.htm#1005029

http://www.oracle.com/technology/oramag/oracle/06-jul/o46sql.html

==========================

Supplement

"Displaying multiple records in one row" give a summary :

1. SELECT wmsys.wm_concat(dname) departments FROM dept;  (10g)

2. A way to get around the restriction that user-defined aggregates may only have one argument, which allows you to specify an alternative separator character.

3. A really delicate way using just sql

SELECT deptno
     , LTRIM(MAX(SYS_CONNECT_BY_PATH(ename,','))
       KEEP (DENSE_RANK LAST ORDER BY curr),',') AS concatenated
FROM   ( SELECT deptno
              , ename
              , ROW_NUMBER() OVER (PARTITION BY deptno ORDER BY ename) AS curr
              , ROW_NUMBER() OVER (PARTITION BY deptno ORDER BY ename) -1 AS prev
         FROM   emp )
GROUP BY deptno
CONNECT BY prev = PRIOR curr AND deptno = PRIOR deptno
START WITH curr = 1;

4. Another approach involves harnessing the dark power of XML

SELECT deptno
     , RTRIM
       ( xmlagg (xmlelement (c, ename || ',') order by ename).extract ('//text()')
       , ',' ) AS concatenated
FROM   emp
GROUP BY deptno;

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

如上篇结束时所言,本篇中着重研究upgradeLock这个方法.

进入方法后第一句就是这个requestedLockMode.greaterThan( entry.getLockMode())判断,若不成立,就马上退出此方法.

有些疑问的是EntityEntry类型的entry里getLockMode有什么意义?再往下追就是EntityEntry里的lockMode是什么时候什么情景下赋值的?

.......................

刚才用Eclipse里实际debug了一番,现在明白了些.

 1,那个LockMode所Lock的是缓存里的Entity,把数据从DB中取出并封装成Java中的对象后,先通过addEntity的方式以entityKey为Key,以实际的Entity为value放入到PersistenceContext中的Map类型的entitiesByKey里,(这也就是SessionLevel的Cache吧?),接下来通过下面的参数:

 EntityEntry e = new EntityEntry(
    status,
    loadedState,
    rowId,
    id,
    version,
    lockMode,
    existsInDatabase,
    persister,
    session.getEntityMode(),
    disableVersionIncrement,
    lazyPropertiesAreUnfetched
 );

组建一个EntityEntry对象,再利用如下语句entityEntries.put(entity, e)把这个新建的EntityEntry作为value同时那个DB数据的包装产物entity作为Key也放入到PersistenceContext里类型为Map的entityEntries对象中.这样就完成了数据从DB到PersistenceContext里迁移,而且在PersistenceContext里已有了Hibernate意义上的LockMode.

 2,这样当开一个Session并利用此Session来get某一个Java对象时,就会先从PersistenceContext里Map来取,若PersistenceContext里有,就取出.这时就要比较当前Session里取Java对象时的LockMode与PersistenceContext里对应EntityEntry里已有的LockMode,若前者大于后者就要来一次upgradeLock,毕竟当把这个Java对象从PersistenceContext里传给业务层后就要保证这个Java对象拥有一个高级别的排它锁,以防止别的Session偷偷地给改掉.这就是方法upgradeLock产生的背景,也正因为此upgradeLock方法也只出现在loadFromSessionCache里. -->不错,把upgradeLock这个方法放在PersistenceContext里来理解一下就通了.

有了上面的分析,对upgradeLock方法的理解就完成一半了.再往下走,就是看这个目标怎么实现了.

就我现在的理解来看,在实现上这个upgradeLock有三个层面的操作:

 1,二级缓存层面:通过生成一个包含当前Session及相关重要属性的CacheKey来锁定,也就是注明在二级缓存中想的那个Java对象已有CacheKey占有了,其它的"哥们儿"就别再花心思想这事了.

 2,PersistenceContext层面:有判断是否isVersioned,从而来保证Version的一致;在PersistenceContext层面来更新LockMode的级别.

 3,DB层面的事务隔离级别:
  persister.lock( entry.getId(), entry.getVersion(), object, requestedLockMode, source );
  下面又有:
   PreparedStatement st = session.getBatcher().prepareSelectStatement( sql );
  于是我就连蒙带猜地认为在DB层面上触及到事务的隔离级别了.

到结尾处有一个问题:
 if ( persister.hasCache() ) {
     persister.getCache().release(ck, lock );
 }

怎么finally里的代码块把前面刚刚Lock的给CacheKey的Entity给放了呢?这又不是session里的Trasaction已经结束了.想不明白,这个以后再慢慢体会吧.

不过看了对finally做的如下注释,
 "the database now holds a lock + the object is flushed from the cache,so release the soft lock"
虽说没有明白这个finally的作用,但似乎有些验证了前面关于"DB层面的事务隔离级别"的猜想.

这个方法终于搞完了.

作为补充,说一下,Hibernate在commit Trasaction时会把EntityEntry里的LockMode重置成最低级别的LockMode.NONE.

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

It's really a pleasure to code in groovy.

My first try:

import groovy.sql.Sql

sql = Sql.newInstance("jdbc:oracle:thin:@ip:port:db","usr","pwd","oracle.jdbc.driver.OracleDriver")

def base  = "/usr/"
def names = []
def today = new java.text.SimpleDateFormat("yyyyMMddHH").format(new Date())

sql.eachRow("select * from user_procedures",{
 names << it.object_name
 })

def cnt = names.size()
names.eachWithIndex({ prc, i ->
 def d = new File(base, "${today}")
 d.mkdir()

 println "${i+1}/$cnt exporting ${prc}.prc...."
 def f = new File(d, "${prc}.prc")
 f << "CREATE OR REPLACE "
 sql.eachRow("select text from user_source where name=? order by line", [prc], {
  f<< it.text 
  })
 })

println "done"

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

Hibernate中"亲子鉴定"

本篇中,我们来看doLoad方法,按上篇的分析方法,我们将这个方法分为三部分:
 step1,loadFromSessionCache()的调用和对返回结果的判断.
 step2,loadFromSecondLevelCache()的调用和对返回结果的判断.
 step3,若上面两个方法的的返回值都为null的话,最后调用loadFromDatasource并返回此方法的返回值.

首先看step1,先不管loadFromDatasource这个方法的执行细节,值得注意的是并没有把结果的判断放入到loadFromDatasource方法里,而是通过判断返回值是否为REMOVED_ENTITY_MARKER或INCONSISTENT_RTN_CLASS_MARKER而分情况地做出log,虽说这两种情况下的最终返回值都是null.另一个值得注意的是虽然loadFromSessionCache可能返回null,但也并没有直接将其返回.这也算是一种编程规范吧:把方法调用及对返回的判断与方法的执行分开,这也很想对Exception的处理,有时根据需要并没有把一些异常都catch起来,而是将其抛出.

关于这个step1,还有一个很值得关注的,那就是特别注意整个系统中debug的安排,这里就特意为debug的需要而创建了两个Object类型的Marker.别的地方虽说也有将debug信息记录下来,但那都是随手而来的debug,不像这特意地绕个弯儿来照顾debug的需要.

有了对step1的分析,doLoad里的step2和step3就没什么特别了的.

下面看loadFromSessionCache方法的执行情况.

由于这里的目标很单一,也就不用再细分N多步了.
首先看第一句,SessionImplementor session = event.getSession();
值得注意的是虽然这个SessionImplementor在onLoad里就从event里获得了,但为了保持代码的精简并没有将那里取得的SessionImplementor作为参数再传到loadFromSessionCache里,而是在这个方法是重新获得,这也正是利用了"指针"的好处,想要什么时就直接获得它的"指针".

接着往下走,从sesion中getEntityUsingInterceptor,这个方法是第一次见,看对这个方法的注释发现了"calling the Interceptor if necessary"这句话.

还没有往下看以前,就觉得有些奇怪,既然这里已经取得了那个Entity为什么不直接返回呢?还要来个处理?接着往下看就发现了这样处理的高明之处:看这个get的Entity的状态,从而决定是否将其返回还是返回那个REMOVED_ENTITY_MARKER或INCONSISTENT_RTN_CLASS_MARKER, 这样的实质也就是任务注册逐层分解,同时也管理好每一次任务分配时的Message反馈,而不是把任务交给你就不管了,同时还要充分考虑到你执行当前任务时可能出现的Message反馈.

以前对EntityEntry这个类老是不能很好地理解,觉得这个名字本身起的就有些怪怪的,Entity就Entity吧,怎么还再来个Entry呢?现在结合这里的实际应用,终于有了很直观的感觉了.
这里有从oldEntry里getStatus的语句,根据这个大致就可以推断出EntityEntry一个用途,那就是Hibernate利用这个类来获得Entity里与Hibernate相关的信息,这样也就理解了Entry一词在这的作用了.

接下往下看,总觉得这段话有点意思:
if ( options.isAllowNulls() ) {
  EntityPersister persister = event.getSession().getFactory().getEntityPersister( event.getEntityClassName() );
  if ( ! persister.isInstance( old, event.getSession().getEntityMode() ) ) {
   return INCONSISTENT_RTN_CLASS_MARKER;
  }
}

先不看那个isAllowNulls的作用,下面的isInstance的判断就些不对劲,感觉夫妻俩生了孩子后不是高兴,而是马上给这个孩子做亲子鉴定!本来嘛,这个Entity就是在与之对应的EntityPersister的一手监管下取得的,而这个Entity"独立"后,竟然对这个Entity做"亲子鉴定",有这个必要吗?

当然,我的这个形象的理解是有问题的,Hibernate经过这么久的考验了,这种"亲子鉴定"真正意义上也没有发生.不过通过这个反映出以前我对EntityPersister的理解还不全,需要进一步的修正.在这里也通过这个形象点的比喻来加强对这个问题重视.

下面是另一个方法upgradeLock了,追着看了下,这个方法是从DefaulLoadEventListener的父类AbstractLockUpgradeEventListener里继承来的.

这个方法很长,只能交给下篇来研究了.

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

在这篇中本来是没想着画EntityPersister接口继承关系及其实现类的类图,可看着看着觉得这个继承关系很壮美,也就很想看到它的全貌,于是就有在这另一篇博客里的类图.

言归正传,来看DefaultLoadEventListener类里的load方法,这个方法里可分为如下三步:
 step1,判断并处理instanceToLoad不为null时的情况.
 step2,做实质的doLoad方法,返回Object类型的对象.
 step3,判断step2里返回的结果,若不符合就抛出相应的异常,从而结束这一超长的get/load操作.

先看step1,这里有个event.getSession().getPersistenceContext().getEntry(event.getInstanceToLoad()) != null判断,(这个Entry是干啥的?)若不为null就抛出"attempted to load into an instance that was already associated with the session: "Message的Exception.对,从这个message也能理解了不为null也就意味着当前PersistenceContext里已有instance.也就是说这个instance与session已关联起来了,那这样先前所假想的那个refresh功能就是错的了.看下面的persister.setIdentifier()方法,我们就可以修正先前的那个关于refresh的假想,或者说是去evolve那个假说:通过设置这个instanceToLoad,我们是想把处于detached状态的对象再次绑定到session里.这不是update的功能么?难道说update在底层就是调用了这个load方法? ----> 以后做进一步的验证.

看step2的doLoad方法,这又是一个独立的方法.只能留到下一篇来详细研究了,不妨也学Hibernate里proxy概念那样,这个load方法将返回一个Object对象,也就是我们想get/load的那个对象.

下面是step3.
 怎么若instanceToLoad不为null就是isOptionalInstance呢?也是说若设置了那个instanceToLoad就说明了这是一种optionalInstance.不理解.
 再看下面的判断逻辑,若是optionalInstance或返回结果不能为null的话,就抛出ObjectNotFoundException.这里的"返回结果不为null"可以理解,但optionalInstance...理解了,这个isOptionalInstance也就意味着,事先已设定了那个instanceToLoad,这样即使get/load没有得到更好的结果(hit database),也不能把已有的那个给能丢了吧,估计正是出于这样的考虑,就把这个也加入ObjectNotFoundException异常的管理之内了.
 有了刚才的分析,下面的这个判断也就好理解了:isOptionalInstance && entity != event.getInstanceToLoad(),也就是说,我已设置了instanceToLoad,你那边get/load到的东西就得放到这个instanceToLoad里边,不能"狸猫换太子"地给调了包,那岂不是赔大了,辛苦了半天到头来给别人做了一番嫁衣.
 至些,经过上面两层的异常筛选,我们就可以返回期盼已久的entity了.
 下一篇中将讨论那个真正的功臣:doLoad.

*****************************************************
这篇blog写完了,总有些意犹未尽的感觉，今天写时有些文如泉涌,呵呵,有些自夸了.思路还很清晰.总得想想/总结下原因吧,对Hibernate的研究是很漫长的过程,这个过程中的研究方法也得慢慢完善起来.

现在总结,最先进入mind里的是刚开始画出的那个类图.很直观,扫清了障碍，也更坚定了信心,心里不再疙疙瘩瘩的,可以亮堂堂地前行.这是成功的心理因素.
第二,今天下班后看救灾方面的新闻,看到了一个女子在被埋的几十个小时里把自己小腿用石块砸开,用自己的鲜血维持着生命!在感叹生命力量如此之大之震撼之余,也让我更深刻地理解了生命潜力的巨大.这样常人能以想像的行动,再发观自己呢,生活中工作中的一点麻烦事就感觉天塌了似的,这怎么行?!有了这样坚定的信念,那个类图也就画出来了,今天的分析也很是成功.
第二,分析方法有了很大的改善.就是把load方法先分为三步,而不是像往常那样,不管三七二十一上来就看.这样的化整为零很见效,事实上,大致地看了一眼这个load方法后也有些犯嘀咕.可当分为三步后,目标一下子更明淅了,心情也就更好了,最终有了后面的文如泉涌.
 呵呵....

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

满城尽是Interface,接口真的那么神奇?

晚饭后由于不能很集中地思考,就大致地看了EntityPersister这个接口的继承关系及其实现类.

呵,真是不看不知道,一看吓一跳,又是一个很庞大的继承树,而且还里有那么多的接口,不禁就感叹了:为什么Hibernate里这么多的接口?这样的接口设计能达到想像的效果么?在解藕合方面真能那么灵验?感觉有些接口过度了,不丁点的小事动不动就来一个接口.说句"大言不惭"的话,在自已的设计中是绝对想不到用这么多接口的.

写着写着,就意识到了:用众多接口而不用众多类是一个以前没想到(或没有这么强烈感觉到)的好处的,那就是利用接口可以视具体情况而做到细粒度的划分,此种情况下不必去考虑其实现类的多少,或更进一步就是不必把实现类也划分的那么细,(若把实现类也划分到接口那样的精细程度,在维护上是很费精力的.)而把这些接口的实现都集中在一起,这样就极好地达到服务与实现的解藕合.或许这就是解藕合的实质吧.

写到这,不由地又想起来这些天稍不留神地会去想去找映证的一个问题:究竟面向对象有什么好处?现在项目虽说是用的Java这一面向对象的语言,但像C语言那样面向过程的设计/编程方式随处可见.每当看到披着Java语言的面向过程就不由地反问,面向对象真的就像某些人所说的那样神奇?

今天由Hibernate里EntityPersister想到的接口带来的好处虽说不能完全消除对"挂着养头卖狗肉"的疑惑,但对面向对象的神奇与伟大有了很直观很切身的体会,再次感谢Hibernate!再次感谢开源软件给俺带来的启发与思考!

****************************************

以前对接口好处的认识也仅仅停留在JavaEE中的Data Object Accessor上,也正是由于这种情况下接口应用很常见,久而久之,习以为常,钝化了思维,心里不免觉得接口设计也不过尔尔嘛,偶尔还自以为是地对自己说掌握了接口设计的精髓.

呵呵,汗颜呀.DAO仅仅是接口发挥威力的一个小小场所.

解藕合:调用与运行分开,服务与实现分开.

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

上一篇重点介绍了LoadEventListener里的LoadType这个static final类及其在LoadEventListener里的定义的几个对象后,简单

地介绍了DefaultLoadEventListener里的三个static final属性,现在在这篇中将重点研究这里的onLoad方法.
 进入onLoad方法后,第一句就是从event中getSession,这个返回值以SessionImplementor类型的变量保存住,如下所示:
  final SessionImplementor source = event.getSession();
 这里边有些蹊跷,LoadEvent类型的变量event里getSession的返回的为EventSource,而看这个EventSource是个接口,再

追着看,EventSource继承自SessionImplementor和Session两个接口,Session就是我们日常所熟悉的org.hibernate.Session接

口,那么这个SessionImplementor接口做何解释?
 看这个接口的继承及实现类关系,此接口继承自Serializable,这没什么特别的;此接口有一个子接口,也就是上面所提

到的EventSource,另有一个抽象类AbstractSessionImpl实现此SessionImplementor接口,此抽象类有两个SessionImpl与

StatelessSessionImpl,这里的SessionImpl就是我们要利用的org.hibernate.Session接口的实现类.

说了半天有些绕,现在再总结下,org.hibernate.Session和SessionImplementor继承自java.io.Serializable,这两个接口下又

有一个共同的了接口EventSource,而org.hibernate.Session有一个子接口

org.hibernate.classic.Session,SessionImplementor有一个抽象实现类AbstractSessionImpl,而Hibernate自身相当重要的一

个类SessionImpl继承自AbstractSessionImpl,并同时实现了EventSource和org.hibernate.classic.Session两个接口,当然它

还实现了另一个接口org.hibernate.jdbc.JDBCContext.Context,由于现在还没有接触这个接口所涉及到的事,先不于考虑.至此

就形成了如下所示的类图(看到这个图后,一下子想起了集万千宠爱于一身这词了,呵呵,能力大责任大.).

 先在这停一下,一直不明白为什么Hibernate里有org.hibernate.classic.Session这个接口,看它里面的22个方法都是

deprecated的,难道说这个接口是历史遗留问题?早与现在常见的org.hibernate.Session接口?这又说不通,若它早于

org.hibernate.Session的话,应该是org.hibernate.Session继承自org.hibernate.classic.Session,而现在正好相反.这做何

解释呢?留到日后随着对Hibernate的慢慢熟悉再来解决吧.
 另外有一个问题,为什么要来一个SessionImplementor接口?心里纳闷Sesion自己就是一个接口了,怎么还又来这么个接

口还起名为SessionImplementor?这个问题从刚开始看Hibernate源码就隐隐约约地感觉到了,随着这些较为专注的研究,终于提

出这个问题,现在把整个关键接口(类)图画出后看出了点门道,准确说是一个猜想:感觉这个SessionImplementor接口有点像JDBC

里给DataBase厂商提供的那套接口,而org.hibernate.Session这个接口是Hibernate给用户用的,这也正像JDBC提供给用户用的

那套接口.现在就先做出这样的假想吧:这个SessionImplementor接口是Hibernate自己方便专门用的一个接口,用它来抽象那些

为实现org.hibernate.Session这个标准接口所要做的一些子功能.
 又说的远了些,回过头来看上面提到的那外第一句.不过现在有以刚才那么几长段的分析,也就很容易明白从event中

getSession后交给一个SessionImplementor"保管"了,虽说放到event里时是已EventSource放的,但取出时也完全可以用

SessionImplementor来保管,毕竟这个SessionImplementor是EventSource的父接口之一.
 
 
 现在已深夜12点了,只能明天再写关于第二句的EntityPersister persister;的EntityPersister类了.呵呵,想来有些

好笑,今天晚就写了对一句话的分析.

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

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

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

1, 为什么tables用的是TreeMap这个类呢?而别的大都用的是HashMap
2, Environment.getProperties()每次调用都是新建一个Properties对象,把这个对象传对调用者.这样做用什么特殊的好处呢?
3, 怪,怎么会出现一模一样的两行LogInfo呢?
 [2008-05-05 09:16:36,750] INFO  org.hibernate.cfg.Environment Hibernate 3.2.6
 [2008-05-05 09:16:36,750] INFO  org.hibernate.cfg.Environment Hibernate 3.2.6
 
 这是log4j配置时哪出错了?
4,跟Tomcat对配置文件的解析相比,Hibernate对配置文件的解析用的是那种DOM,也就是说把XML文件生成一个Document放在内存中,什么时候用就直接用.而Tomcat像是用SAX解析方式,根据解析事件去配置相应的Component.

5,url.openStream()?为什么要用这个而不用那种直接的打开方式呢?

6,注意有两个类Mappings与Mapping,
 Mappings是在解析hbm.xml时

7,hibernate-mapping里的子元素Meta还没有用过.这个怎么与别的联系起来?

8,有专门的extractRootAttributes方法来get RootNote下的attributes,这也进一步证明了上面的Meta是RootNode的子元素而不是其属性.

9,看hibernate-mapping-3.0.dtd又进一步想到了正则表达式中也会用到的*?等对个数限制的描述符.
 *: 表示任意个数,0 --> N.
 ?: 表示0 or 1吗现在也不确定了.
10,dtd描述文件中的像如下所示中的
 <!ATTLIST hibernate-mapping default-cascade CDATA "none">

 CDATA是什么意思?

11,Map put时的一个新发现:
 Object old = classes.put( persistentClass.getEntityName(), persistentClass );
  if ( old!=null ) {
   throw new DuplicateMappingException( "class/entity", persistentClass.getEntityName() );
 }

 Hibernate中有如上的应用,也就是说可以能过put的返回值是否为null来判断是否覆盖了Map中与Key相对的原用Entity.不错.

 再看API,对put的返回值有如下描述:
 the previous value associated with  key , or null  if there was no mapping for  key .(A  null  return can also indicate that the map previously associated  null  with  key , if the implementation supports  null  values.)

12,HmbBinder类中的bindPojoRepresentation这三个方法bind的是从DB返回后的包装类型么？

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

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

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

1, Collections.unmodifiableMap( new HashMap(0) );

          看到了这样的语句,不知道个unmodifiableMap在实际中有什么用?

         是说整个执行过程中,某一个变量所指向的Instance没有是不可modifiable的吧?而不是这个Map中的具体内容. 这样再结合应用的上下文就通了.

2,Hibernate中有个SecondPass的概念,这个是干啥用的?

      看源码时,它的实现类中有这样的关系:

           接口SecondPass有两个直接实现类:

                      CollectionSecondPass和ManyToOneSecondPass,另还有一个继承于此接口的子接口QuerySecondPass

                        CollectionSecondPass在HbmBinder类中又定义了一个static的类名为HbmBinder.CollectionSecondPass,   这个静态类在HbmBinder中又分别有三个子类(也是静态的)它们是IdentifierCollectionSecondPass,ListSecondPass,MapSecondPass.

                        ManyToOneSecondPass这个类也是静态的,它也是在HbmBinder类中定义的内部类.

                  QuerySecondPass接口有两个实现类ResultSetMappingSecondPass和    NamedSQLQuerySecondPass,这两个类都ResultSetMappingBinder的子类.

3,Hibernate N步曲:

    1>,new Configuration(): 找hibernate.properties文件,初始化所有Listeners,classes,imports,secondPasses....

    2>,configure(): 找到hibernate.hbm.xml文件,将其中的元素解析出来放到Configuration类中的相应的properties里,据cfg.xml文件中指定的hbm.xml名称找到并解析XXX.hbm.xml文件,将配置放到Configuration类中相应的属性中,如classes,imports,collections,tables,sqlFunctions,namedQueries....

    3>,buildSessionFactory:据第二步中生成的Configurations类中的相应属性生成CRUD相关的Sql语句,identifierGenerators,entityPersisters,collectionPersisters... 这一步是Mapping路上实质性的一步.

    4>,有了第三步的准备,就可以调用Session接口中面向对象的CRUD操作了.

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