亚洲精品免费在线视频,亚洲精品视频久久久,亚洲AV永久无码精品一福利

Frank_Fang — Sat, 08 Aug 2009 16:14:00 GMT

http://www.javaeye.com/topic/15057

值得研究一�?br />

Frank_Fang 2009-08-09 00:14 发表评论

Frank_Fang — Sat, 08 Aug 2009 15:35:00 GMT

1�Q��用Spring �?ActionSupport
2, 使用Spring �?DelegatingRequestProcessor �c�R�?br /> 3�Q�全权委托�?/p>

无论用那�U�方法来整合�W�一步就是要为struts来装载spring的应用环境�?��是�?struts 中加入一个插件�?br /> struts-config.xml�?/p>

="/WEB-INF/applicationContext.xml"/>

spring 的配�|�文件被作�ؓ参数配置�q�来。这样可以省略对web.xml 文�g中的配置�?span style="color: #ff0000">��保你的applicationContext.xml 在WEB-INF目录下面

1�Q��用Spring的ActionSupport .
Spring 的ActionSupport �l�承�?org.apache.struts.action.Action
ActionSupport的子�c�d��以或�?WebApplicationContext�c�d��的全局变量。通过getWebApplicationContext()可以获得�q�个变量�?/p>

�q�是一�?servlet 的代码：
public class LoginAction extends org.springframework.web.struts.ActionSupport {

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
                //获得 WebApplicationContext 对象
  WebApplicationContext ctx = this.getWebApplicationContext();

  LoginDao dao = (LoginDao) ctx.getBean("loginDao");
  User u = new User();

  u.setName(loginForm.getName());
  u.setPwd(loginForm.getPwd());


  if(dao.checkLogin(u)){
   return mapping.findForward("success");
  }else{
   return mapping.findForward("error");
  }

}
}

applicationContext.xml 中的配置

�q�中配置方式同直接在web.xml文�g配置差别不大。注意：Action�l�承�?org.springframework.web.struts.ActionSupport 使得struts和spring耦合在一赗��?br /> 但实��C��表示层和业务逻辑层的解�?LoginDao dao = (LoginDao) ctx.getBean("loginDao"))�?/p>

2,使用Spring �?DelegatingRequestProcessor �c?/strong>
DelegatingRequestProcessor �l�承�?org.apache.struts.action.RequestProcessor �q�覆盖了里面的方法�?br /> sturts-config.xml �?nbsp; 通过来替�?br /> org.apache.struts.action.RequestProcessor 的请求处理�?/p>

public class LoginAction extends Action {
//利用spring来注入这个对象�?br /> private LoginDao dao ;

public void setDao(LoginDao dao) {
System.out.println("执行注入");
this.dao = dao;
}

public LoginDao getDao() {
  return dao;
}

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stub
  //�q�样一改这行代码似乎没有必要了�?br />   //WebApplicationContext ctx = this.getWebApplicationContext();
  //LoginDao dao = (LoginDao) ctx.getBean("loginDao");

  User u = new User();

  u.setName(loginForm.getName());
  u.setPwd(loginForm.getPwd());

  //直接用dao来调用spring会将�q�个对象实例化�?br />   if(dao.checkLogin(u)){
   return mapping.findForward("success");
  }else{
   return mapping.findForward("error");
  }

}
}
�q�里的�?br /> LoginAction extends Action 说明 struts 每有和spring 耦合�?br /> 看一�?br /> applicationContext.xml 中的配置�?br />

name="/login" class="com.cao.struts.action.LoginAction">




�q�里 name="/login" 与struts 中的path匚w��
    class="com.cao.struts.action.LoginAction" 与struts 中的type匚w��

�q�要�?LoginAction 提供必要的setXXX�Ҏ��?获得ApplicationCotext和依赖注入的工作都在DelegatingRequestProcessor中完成�?/p>

3�Q�全权委托：
Action 的创建和对象的依赖注入全部由IOC容器来完成�?使用Spring的DelegatingAcionProxy来帮助实��C��理的工作
org.springframework.web.struts.DelegatingActiongProxy�l�承于org.apache.struts.action.Action .

全权委托的配�|�方式同方式 2 �c�M�� (applcationContext.xml文�g的配�|�和 Action�cȝ��实现方式相同)�?br />




          attribute="loginForm"
      input="login.jsp"
      name="loginForm"
      path="/login"
      scope="request"

      type="org.springframework.web.struts.DelegatingActionProxy" >









不同之处
1�Q?�?type指向的是spring 的代理类

2�Q?��L��struts-config.xml�?

三种整和方式中我们优先选用全权委托的方式�?br /> 理由�Q?br /> 1�Q�第一�U��得过多的耦合了Spring和Action .
2,RequestProcessor�c�d��l�被代理如果要再实现自己的实现方式（如：�~�码处理�Q�怕有炚w��烦�?/p>
�ȝ��一下：
整合工作中的步骤�Q?br /> 1�Q�修改struts-config.xml
2, 配置applicationContext.xml
3, 为Action��d��get/set�Ҏ�� 来获得依赖注入的功能�?/p>
本文转自�Q?a >http://blog.csdn.net/caoyinghui1986/archive/2008/06/02/2501914.aspx

Frank_Fang 2009-08-08 23:35 发表评论

解惑 spring 嵌套事务

Frank_Fang — Sat, 01 Aug 2009 16:05:00 GMT

解惑 spring 嵌套事务 http://www.javaeye.com/topic/35907?page=1

Spring声明式事务管理源码解��M��事务开�?http://www.javaeye.com/topic/87426

Spring声明式事务管理源码解��M��事务提交 http://www.javaeye.com/topic/88189

Frank_Fang 2009-08-02 00:05 发表评论

【�{】关于oracle数据库隔��ȝ�别isolation level 的一些问题！

Frank_Fang — Sat, 01 Aug 2009 10:16:00 GMT

oracle中锁的类型：
然后再读时不需要加锁，�q�一点Oracle的共享锁的实��C��上一��中的共享锁原理有点不同�Q?/strong>

今天在查看oracle官方文档lock的那一部分的时候发��C��个新的概念，isolation level (数据隔离�U�别)�Q�虽然以前学�q�，但是忘的差不多了�?br /> 隔离�U�别�Q�isoation eve�Q?/strong>
隔离�U�别定义了事务与事务之间的隔��ȝ��度�?/p>
隔离�U�别与�ƈ发性是互�ؓ矛盾的：隔离�E�度��高�Q�数据库的�ƈ发性越差；隔离�E�度��低�Q�数据库的�ƈ发性越好�?/p>
ANSI/ISO SQ92标准定义了一些数据库操作的隔��ȝ�别：

未提交读�Q�read uncommitted�Q?
提交读（read committed�Q?nbsp;
重复读（repeatabe read�Q?nbsp;
序列化（seriaizabe�Q?

通过一些现象，可以反映出隔��ȝ�别的效果。这些现象有�Q?/p>

更新丢失�Q�ost update�Q�：当系�l�允�怸�个事务同时更新同一数据是，发生更新丢失�?nbsp;
脏读�Q�dirty read�Q�：当一个事务读取另一个事务尚未提交的修改�Ӟ��产生脏读�?
�?重复读（nonrepeatabe read�Q�：同一查询在同一事务中多�ơ进行，�׃��其他提交事务所做的修改或删除，每次�q�回不同的结果集�Q�此时发生非重复诅R�?A transaction rereads data it has previousy read and finds that another committed transaction has modified or deeted the data. )
�q?像（phantom read�Q�：同一查询在同一事务中多�ơ进行，�׃��其他提交事务所做的插入操作�Q�每�ơ返回不同的�l�果集，此时发生�q�d��诅R�?A transaction reexecutes a query returning a set of rows that satisfies a search condition and finds that another committed transaction has inserted additiona rows that satisfy the condition. )

下面是隔��ȝ�别及其对应的可能出现或不可能出现的现�?/p>

Dirty Read NonRepeatabe Read Phantom Read

Read uncommitted Possible Possible Possible

Read committed not possible Possible Possible

Repeatabe read not possible not possible Possible

Seriaizabe not possible not possible not possible

ORACE的隔��ȝ��?/strong>

ORACE提供了SQ92标准中的read committed和seriaizabe�Q�同时提供了非SQ92标准的read-ony�?/p>
read committed�Q?/strong>

�q�是ORACE�~�省的事务隔��ȝ�别�?/font>
事务中的每一条语句都遵从语句�U�的��M��致性�?
保证不会脏读�Q�但可能出现非重复读和��像�?

seriaizabe�Q�（串行执行事务�Q��ƈ发性最��）

��单地��_��seriaizabe��是使事务看��h��象是一个接着一个地��序地执行�?/font>
仅仅能看见在本事务开始前由其它事务提交的更改和在本事务中所做的更改�?
保证不会出现非重复读和��像�?
Seriaizabe隔离�U�别提供了read-ony事务所提供的读一致性（事务�U�的��M��致性）�Q�同时又允许DM操作�?

如果有在seriaizabe事务开始时未提交的事务在seriaizabe事务�l�束之前修改了seriaizabe事务��要修改的行�q�进行了提交�Q�则seriaizabe事务不会��d��q�些变更�Q�因此发生无法序列化讉K��的错误。（换一�U�解释方法：只要在seriaizabe事务开始到�l�束之间有其他事务对seriaizabe事务要修改的东西�q�行了修改�ƈ提交了修改，则发生无法序列化讉K��的错�?/strong>。）

If a serializable transaction contains data manipulation language (DML) that attempts to update any resource that may have been updated in a transaction uncommitted at the start of the serializable transaction, �Q��ƈ且修改在后来被提交而没有回滚）�Q�then the DML statement fails. �q�回的错误是ORA-08177: Cannot serialize access for this transaction�?/p>
ORACE在数据块中记录最�q�对数据行执行修�Ҏ��作的N个事务的信息�Q�目的是��定本事务开始时�Q�是否存在未提交的事务修改了本事务将要修改的行。具体见英文�Q?/p>
Oracle permits a serializable transaction to modify a data row only if it can determine that prior changes to the row were made by transactions that had committed when the serializable transaction began.

To make this determination efficiently, Oracle uses control information stored in the data block that indicates which rows in the block contain committed and uncommitted changes. In a sense, the block contains a recent history of transactions that affected each row in the block. The amount of history that is retained is controlled by the INITRANS parameter of CREATE TABLE and ALTER TABLE. Under some circumstances, Oracle may have insufficient history information to determine whether a row has been updated by a "too recent" transaction. This can occur when many transactions concurrently modify the same data block, or do so in a very short period. You can avoid this situation by setting higher values of INITRANS for tables that will experience many transactions updating the same blocks. Doing so will enable Oracle to allocate sufficient storage in each block to record the history of recent transactions that accessed the block.

The INITRANS Parameter�Q�Oracle stores control information in each data block to manage access by concurrent transactions. Therefore, if you set the transaction isolation level to serializable, you must use the ALTER TABLE command to set INITRANS to at least 3. This parameter will cause Oracle to allocate sufficient storage in each block to record the history of recent transactions that accessed the block. Higher values should be used for tables that will undergo many transactions updating the same blocks.

read-ony�Q?/strong>

遵从事务�U�的��M��致性，仅仅能看见在本事务开始前由其它事务提交的更改�?
不允许在本事务中�q�行DM操作�?
read ony是seriaizabe的子集。它们都避免了非重复��d��q�d��。区别是在read ony中是只读�Q�而在seriaizabe中可以进行DM操作�?
Export with CONSISTENT = Y sets the transaction to read-ony.

read committed和seriaizabe的区别和联系�Q?/strong>

事务1先于事务2开始，�q�保持未提交状态。事�?惌��修改正被事务1修改的行。事�?�{�待。如果事�?回滚�Q�则事务2�Q�不论是read committed�q�是seriaizabe方式�Q�进行它惌��做的修改。如果事�?提交�Q�则当事�?是read committed方式�Ӟ��q�行它想要做的修改；当事�?是seriaizabe方式�Ӟ��p�|�q�报�?#8220;Cannot seriaize access”�Q�因��Z��?看不见事�?提交的修改，且事�?惛_��事务1修改的基��上再做修攏V�?/p>
即seriaizabe不允许存在事务嵌�?/p>
具体见英文：

Both read committed and serializable transactions use row-level locking, and both will wait if they try to change a row updated by an uncommitted concurrent transaction. The second transaction that tries to update a given row waits for the other transaction to commit or roll back and release its lock. If that other transaction rolls back, the waiting transaction (regardless of its isolation mode) can proceed to change the previously locked row, as if the other transaction had not existed. However, if the other (blocking) transaction commits and releases its locks, a read committed transaction proceeds with its intended update. A serializable transaction, however, fails with the error "Cannot serialize access", because the other transaction has committed a change that was made since the serializable transaction began.

read committed和seriaizabe可以在ORACE�q�行服务器中使用�?/p>
关于SET TRANSACTION READ WRITE�Q�read write和read committed 应该是一��L��。在��L��面，它们都避免了脏读�Q�但都无法实现重复读。虽然没有文档说明read write在写斚w��与read committed一��_��但显然它在写的时候会加排他锁以避免更��C��失。在加锁的过�E�中�Q�如果遇到待锁定资源无法锁定�Q�应该是�{�待而不是放弃。这�?read committed一致�?/p>
语句�U�的��M��致�?/p>

ORACE保证语句�U�的��M��致性，即一个语句所处理的数据集是在单一旉��点上的数据集�Q�这个时间点是这个语句开始的旉��?
一个语句看不见在它开始执行后提交的修攏V�?
对于DM语句�Q�它看不见由自己所做的修改�Q�即DM语句看见的是它本�w�开始执行以前存在的数据�?

事务�U�的��M��致�?/p>

事务�U�的��M��致性保证了可重复读�Q��ƈ保证不会出现�q�d��?

讄��隔离�U�别

讄��一个事务的隔离�U�别

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SET TRANSACTION READ ONLY;

讄��增个会话的隔��ȝ��?/p>

ATER SESSION SET ISOLATION_LEVE SERIALIZABLE;
ATER SESSION SET ISOLATION_LEVE READ COMMITTED;

Choice of Isolation Level

Application designers and developers should choose an isolation level based on application performance and consistency needs as well as application coding requirements.

For environments with many concurrent users rapidly submitting transactions, designers must assess transaction performance requirements in terms of the expected transaction arrival rate and response time demands. Frequently, for high-performance environments, the choice of isolation levels involves a trade-off between consistency and concurrency.

Read Committed Isolation

For many applications, read committed is the most appropriate isolation level. Read committed isolation can provide considerably more concurrency with a somewhat increased risk of inconsistent results due to phantoms and non-repeatable reads for some transactions.

Many high-performance environments with high transaction arrival rates require more throughput and faster response times than can be achieved with serializable isolation. Other environments that supports users with a very low transaction arrival rate also face very low risk of incorrect results due to phantoms and nonrepeatable reads. Read committed isolation is suitable for both of these environments.

两种情况�Q�（1�Q�在事务量大、高性能的计��环境，需要更高的吞吐量和响应旉��Q�（2�Q�事务数��，�q�且发生�q�d��和不可重复读的几率的比较�?/p>
Oracle read committed isolation provides transaction set consistency for every query. That is, every query sees data in a consistent state. Therefore, read committed isolation will suffice for many applications that might require a higher degree of isolation if run on other database management systems that do not use multiversion concurrency control.

Read committed isolation mode does not require application logic to trap the "Cannot serialize access" error and loop back to restart a transaction. In most applications, few transactions have a functional need to issue the same query twice, so for many applications protection against phantoms and non-repeatable reads is not important. Therefore many developers choose read committed to avoid the need to write such error checking and retry code in each transaction.

Serializable Isolation

Oracle's serializable isolation is suitable for environments where there is a relatively low chance that two concurrent transactions will modify the same rows and the long-running transactions are primarily read-only. It is most suitable for environments with large databases and short transactions that update only a few rows.

�Q?�Q�适合于很��存在两个事务同时修改同一条记录的情况

�Q?�Q�长事务以只��Mؓ�?/p>
�Q?�Q�大型数据库�q�且每个短事务只修改很少的记�?/p>
Serializable isolation mode provides somewhat more consistency by protecting against phantoms and nonrepeatable reads and can be important where a read/write transaction executes a query more than once.

Unlike other implementations of serializable isolation, which lock blocks for read as well as write, Oracle provides nonblocking queries and the fine granularity of row-level locking, both of which reduce write/write contention. For applications that experience mostly read/write contention, Oracle serializable isolation can provide significantly more throughput than other systems. Therefore, some applications might be suitable for serializable isolation on Oracle but not on other systems.

All queries in an Oracle serializable transaction see the database as of a single point in time, so this isolation level is suitable where multiple consistent queries must be issued in a read/write transaction. A report-writing application that generates summary data and stores it in the database might use serializable mode because it provides the consistency that a READ ONLY transaction provides, but also allows INSERT, UPDATE, and DELETE.

Frank_Fang 2009-08-01 18:16 发表评论

Frank_Fang — Sat, 01 Aug 2009 06:17:00 GMT
     摘要: http://www.javaeye.com/topic/78674 回帖中也有些需要注意的地方。。可以仔�l�看�? 先了解一下数据库�q�发操作带来的数据不一致性包括三�c�：丢失修改�Q�不可重复读�Q�第二个事务修改�Q�或插入�Q�或删除�Q�应该说�q�读是指插入或删除的情况�Q�，脏读�? T1 ...  阅读全文

Frank_Fang 2009-08-01 14:17 发表评论

【�{】解析oracle的ROWNUM

Frank_Fang — Thu, 30 Jul 2009 15:43:00 GMT

对于rownum来说它是oracle�pȝ��序分配��Z��查询�q�回的行的编��P��q�回的第一行分配的�?�Q�第二行�?�Q�依此类推，�q�个伪字�D�可以用于限制查询返回的总行敎ͼ�而且rownum不能以�Q何表的名�U�C��为前�~��?br /> 举例说明�Q?br /> 例如表：student(学生)表，表结构�ؓ�Q?br /> ID　　　    char(6)　　　　　 --学号
name　　　　VARCHAR2(10)　　　--姓名
create table student (ID char(6), name VARCHAR2(100));
insert into sale values('200001',‘张一’);
insert into sale values('200002',‘王二’);
insert into sale values('200003',‘李三’);
insert into sale values('200004',‘赵四’);
commit;

(1) rownum 对于�{�于某值的查询条�g
如果希望扑ֈ�学生表中�W�一条学生的信息�Q�可以��用rownum=1作�ؓ条�g。但是想扑ֈ�学生表中�W�二条学生的信息�Q��用rownum=2�l�果查不到数据。因为rownum都是�?开始，但是1以上的自然数在rownum做等于判断是时认为都是false条�g�Q�所以无法查到rownum = n�Q�n>1的自然数�Q��?br /> SQL> select rownum,id,name from student where rownum=1;�Q�可以用在限制返回记录条数的地方�Q�保证不出错�Q�如�Q�隐式游标）
SQL> select rownum,id,name from student where rownum=1;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200001 张一
SQL> select rownum,id,name from student where rownum =2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------

�Q?�Q�rownum对于大于某值的查询条�g
   如果��x��C��W�二行记录以后的记录�Q�当使用rownum>2是查不出记录的，原因是由于rownum是一个��L��?开始的伪列�Q�Oracle 认�ؓrownum> n(n>1的自然数)�q�种条�g依旧不成立，所以查不到记录
SQL> select rownum,id,name from student where rownum >2;
ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
那如何才能找到第二行以后的记录呀。可以��用以下的子查询方法来解决。注意子查询中的rownum必须要有别名�Q�否则还是不会查��录来�Q�这是因为rownum不是某个表的列，如果不�v别名的话�Q�无法知道rownum是子查询的列�q�是��L��询的列�?br /> SQL>select * from(select rownum no ,id,name from student) where no>2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         4 200004 赵四
SQL> select * from(select rownum,id,name from student)where rownum>2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------

�Q?�Q�rownum对于��于某值的查询条�g
如果��x��到第三条记录以前的记录，当��用rownum<3是能得到两条记录的。显然rownum对于rownum1的自然数�Q�的条�g认�ؓ是成立的�Q�所以可以找到记录�?br /> SQL> select rownum,id,name from student where rownum <3;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
        1 200001 张一
        2 200002 王二
�l�g��几种情况�Q�可能有时候需要查询rownum在某区间的数据，那怎么办呀从上可以看出rownum对小于某值的查询条�g是�h为true的，rownum对于大于某值的查询条�g直接认�ؓ是false的，但是可以间接的让它�{��为是true的。那��必��M��用子查询。例如要查询rownum在第二行到第三行之间的数据，包括�W�二行和�W�三行数据，那么我们只能写以下语句，先让它返回小于等于三的记录行�Q�然后在��L��询中判断新的rownum的别名列大于�{�于二的记录行。但是这��L��操作会在大数据集中媄响速度�?br /> SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         2 200002 王二
         3 200003 李三

�Q?�Q�rownum和排�?br /> Oracle中的rownum的是在取数据的时候��生的序号�Q�所以想�Ҏ��定排序的数据��L��定的rowmun行数据就必须注意了�?br /> SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出�Q�rownum�q�不是按照name列来生成的序受��系�l�是按照记录插入时的��序�l�记录排的号�Q�rowid也是��序分配的。�ؓ了解册��个问题，必须使用子查�?br /> SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
�q�样��成了按name排序�Q��ƈ且用rownum标出正确序号�Q�有��到大）
�W�者在工作中有一上百万条记录的表�Q�在jsp��面中需对该表进行分��|��C�，便考虑用rownum来作�Q�下面是具体�Ҏ��(每页
昄��20�?�Q?
“select * from tabname where rownum<20 order by name" 但却发现oracle却不能按自己的意愿来执行�Q�而是先随�?br /> �?0条记录，然后�?order by�Q�后�l�咨询oracle,说rownum��实��p��P��想用的话�Q�只能用子查�?来实现先排序�Q�后
rownum�Q�方法如下：
"select * from (select * from tabname order by name) where rownum<20",但这样一来，效率会较低很多�?
后经�W�者试验，只需在order by 的字�D�上加主键或索引卛_��让oracle先按该字�D�|��序，然后再rownum�Q�方法不变：
   “select * from tabname where rownum<20 order by name"

取得某列中第N大的�?/p>
select column_name from
(select table_name.*,dense_rank() over (order by column desc) rank from table_name)
where rank = &N�Q?
　假如要返回前5条记录：

　　select * from tablename where rownum<6;(或是rownum <= 5 或是rownum != 6)
假如要返回第5-9条记录：

select * from tablename
where …
and rownum<10
minus
select * from tablename
where …
and rownum<5
order by name
选出�l�果后用name排序昄��l�果�?先选再排序)

注意�Q�只能用以上�W�号(<�?lt;=�?=)�?/p>
select * from tablename where rownum != 10;�q�回的是前９条记录�?
不能用：>,>=,=,Between...and。由于rownum是一个��L��?开始的伪列�Q�Oracle 认�ؓ�q�种条�g 不成立，查不到记�?

另外�Q�这个方法更快：

select * from (
select rownum r,a from yourtable
where rownum <= 20
order by name )
where r > 10
�q�样取出�W?1-20条记�?(先选再排序再�?

要先排序再选则��ȝ��select嵌套�Q�内层排序外层选�?
rownum是随着�l�果集生成的�Q�一旦生成，��׃��会变化了�Q�同�?生成的结果是依次递加的，没有1��永�q�不会有2!
rownum 是在查询集合产生的过�E�中产生的伪列，�q�且如果where条�g中存�?rownum 条�g的话�Q�则:

1�Q?假如判定条�g是常量，则：
只能 rownum = 1, <= 大于1 的自然数�Q?= 大于1 的数是没有结果的�Q?大于一个数也是没有�l�果�?
�?当出��C��?rownum 不满��x��件的时候则查询�l�束　　this is stop key!

2: 当判定��g��是常量的时�?
若条件是 = var , 则只有当 var �? 的时候才满��条�g�Q�这个时候不存在 stop key ,必须�q�行 full scan ,�Ҏ��个满��_��他where条�g的数据进行判�?
选出一行后才能去选rownum=2的行……

Frank_Fang 2009-07-30 23:43 发表评论

Frank_Fang — Tue, 28 Jul 2009 11:43:00 GMT

查到很多�Q�能理解的就�q�几条了�Q?/p>
   �Q?�Q�回�?日志。DELETE语句执行删除的过�E�是每次从表中删除一行，�q�且同时��该行的的删除操作作��Z��务记录在日志中保存以便进行进行回滚操作。TRUNCATE TABLE 则一�ơ性地从表中删除所有的数据��ƈ不把单独的删除操作记录记入日志保存，删除行是不能恢复的。�ƈ且在删除的过�E�中不会�Ȁ�z�M��表有关的删除触发器。执行速度快�?/p>
   �Q?�Q�表和烦引所占空间。当表被TRUNCATE 后，�q�个表和索引所占用的空间会恢复到初始大��，而DELETE操作不会减少表或索引所占用的空间�?/p>
   �Q?�Q�应用范围。TRUNCATE 只能对TABLE�Q�DELETE可以是table,view,synonym

   �Q?�Q�TRUNCATE 和DELETE只删除数据，而DROP则删除整个表�Q�结构和数据�Q��?

   �Q?�Q�TRUNCATE 是DDL�Q�DELETE是DML�?/p>

truncate、delete�Q�不带where子句�Q�与drop的异同点�Q?br /> 相同之处�Q?br />     三者均会删除表内的data�?br /> 不同点：
   <1>、truncate与不带where的delete �Q�只删除数据�Q�而不删除表的�l�构�Q�定义）
        drop语句��删除表的结构被依赖的约束（constrain),触发器（trigger), 索引�Q�index);依赖于该表的存储�q�程/函数��被保留�Q�但其状态会变�ؓ�Q�invalid�?br />    <2>、delete语句为DML�Q�data maintain Language),�q�个操作会被攑ֈ� rollback segment�?事务提交后才生效。如果有相应�?tigger,执行的时候将被触发�?br />        truncate、drop是DLL�Q�data define language),操作立即生效�Q�原数据不放�?rollback segment中，不能回滚�Q�操作不触发 trigger�?br />    <3>、delete语句不媄响表所占用�?extent�Q�段�Q?高水�U�（high watermark)保持原位�|�不动�?br />          drop语句��表所占用的空间全释放掉�?br />          truncate语句�~�省情况下将�I�间释放�?minextents �?extent,除非使用 renuse storage;truncate 会将高水�U?high watermark)复位�Q�回到最初位�|�）�?br />    <4>、速度�Q?br />       一般而言�Q�drop > truncate > delete�?br />    <5>、安全性：
       在没有备份情况下�Q��}慎��?drop �?truncate。要删除部分数据行采�?delete且注意结合where来约束媄响范围。回滚段要��够大。要删除表用drop;若想保留表而将表中数据删除�Q�如果于事务无关�Q�用truncate卛_��实现。如果和事务有关�Q�或老师惌��发trigger,�q�是用delete�?br />       如果是整理表内部的碎片，可以用truncate�q�结合reuse storage,再重新导�?插入数据�?br /> 附Microsoft SQL
Truncate是SQL中的一个删除数据表内容的语句，用法是：
TRUNCATE TABLE [Table Name]�?br /> 下面是对Truncate语句在MSSQLServer2000中用法和原理的说明：
Truncate table 表名速度�?而且效率�?因�ؓ:
truncate table 在功能上与不�?WHERE 子句�?DELETE 语句相同�Q�二者均删除表中的全部行。但 TRUNCATE TABLE �?DELETE 速度快，且��用的�pȝ��和事务日志资源少�?
DELETE 语句每次删除一行，�q�在事务日志中�ؓ所删除的每行记录一��V��TRUNCATE TABLE 通过释放存储表数据所用的数据��|��删除数据�Q��ƈ且只在事务日志中记录��늚�释放�?
TRUNCATE TABLE 删除表中的所有行�Q�但表结构及其列、约束、烦引等保持不变。新行标识所用的计数值重�|��ؓ该列的种子。如果想保留标识计数��|��h��?DELETE。如果要删除表定义及其数据，请��?DROP TABLE 语句�?
对于�?FOREIGN KEY �U�束引用的表�Q�不能��?TRUNCATE TABLE�Q�而应使用不带 WHERE 子句�?DELETE 语句。由�?TRUNCATE TABLE 不记录在日志中，所以它不能�Ȁ�z�触发器�?
TRUNCATE TABLE 不能用于参与了烦引视囄��?/p>

Frank_Fang 2009-07-28 19:43 发表评论

【�{】MySql常用命��o

Frank_Fang — Fri, 24 Jul 2009 16:24:00 GMT

mysql alter命定
关键�? mysql
mysql alter 语句用法,��d��、修攏V��删除字�D늭�

//主键549830479

   alter table tabelname add new_field_id int(5) unsigned default 0 not null auto_increment ,add primary key (new_field_id);
//增加一个新�?49830479

   alter table t2 add d timestamp;
alter table infos add ex tinyint not null default '0';
//删除�?49830479

   alter table t2 drop column c;
//重命名列549830479

   alter table t1 change a b integer;

//改变列的�c�d��549830479

   alter table t1 change b b bigint not null;
alter table infos change list list tinyint not null default '0';

//重命名表549830479

   alter table t1 rename t2;
加烦�?49830479

   mysql> alter table tablename change depno depno int(5) not null;
mysql> alter table tablename add index 索引�?(字段�?[�Q�字�D�名2 …]);
mysql> alter table tablename add index emp_name (name);
加主关键字的索引549830479

mysql> alter table tablename add primary key(id);
加唯一限制条�g的烦�?49830479

mysql> alter table tablename add unique emp_name2(cardnumber);
删除某个索引549830479

   mysql>alter table tablename drop index emp_name;
修改表：549830479

增加字段�Q?49830479

   mysql> ALTER TABLE table_name ADD field_name field_type;
修改原字�D�名�U�及�c�d��Q?49830479

   mysql> ALTER TABLE table_name CHANGE old_field_name new_field_name field_type;
删除字段�Q?49830479

   mysql> ALTER TABLE table_name DROP field_name;

mysql 常用增删�Ҏ��命定
关键�? mysql增删�Ҏ��
插入一条记�?
          mysql> insert into table_name (column_name1,column_name2,.) values (value1,value2,..);
更新一条记录：
          mysql> update tbl_name
set col_name1=expr1 [, col_name2=expr2 ...][WHERE where_definition]
[ORDER BY ...][LIMIT row_count];
删除一条记录：
         mysql>delete from table_name where id=XX;
删除整个表的数据�Q?
         mysql> drop from table_name;
查询一条记录：
         mysql>select * from table_name where id=XX;

mysql中删除部分重复记录的�Ҏ��
关键�? mysql中删除部分重复记�?
假设person表中有三个字�D?分别是id(自增) name age 部分记录中的name ,age出现重复
比如
id             name              age
1           zhangsan            20
2           zhangsan            20
3               lisi                    25
4               lisi                    25
1 ,2 部分重复�Q?,4也是部分重复 �Q�现在四条记录我只保留不重复的两条。删除方法如下：

1.按name,age分组查询出所有不重复的id�q�放入到tmp表中
create table tmp select min(id) as id from person group by name,age;

2.�Ҏ��上面查询出的id号从person表中查询出所有的数据�q�放到表tmp2�?
create table tmp2 select person.* from person,tmp where person.id = tmp.id;

3.删除person�?
drop table person;

4.把tmp2重命名�ؓperson
rename table tmp2 to person;

Frank_Fang 2009-07-25 00:24 发表评论

[转]MySQL索引

Frank_Fang — Fri, 24 Jul 2009 16:11:00 GMT
在数据库表中�Q��用烦引可以大大提高查询速度�?

假如我们创徏了一个testIndex�?
create TABLE testIndex(i_testID INT NOT NULL,vc_Name VARCHAR(16) NOT NULL);

我们随机向里面插入了1000条记录，其中有一�?
    i_testID    vc_Name
      555    erquan

在查找vc_Name="erquan"的记�?
select * FROM testIndex where vc_Name='erquan';
�Ӟ��如果在vc_Name上已�l�徏立了索引�Q�MySql无须��M��扫描�Q�即准确可找到该记录�Q�相反，MySql会扫描所有记录，卌��查询1000�ơ啊~~可以索引��查询速度提高100倍�?

一、烦引分单列索引和组合烦�?
   单列索引�Q�即一个烦引只包含单个列，一个表可以有多个单列烦引，但这不是�l�合索引�?
   �l�合索引�Q�即一个烦包含多个列�?

二、介�l�一下烦引的�c�d��

    1.普通烦引�?
      �q�是最基本的烦引，它没有�Q何限制。它有以下几�U�创建方式：
       �Q?�Q�创建烦引：create INDEX indexName ON tableName(tableColumns(length));如果是CHAR,VARCHAR�c�d��Q�length可以��于字段实际长度;如果�?BLOB �?TEXT �c�d��Q�必��L��定length�Q�下同�?
      �Q?�Q�修改表�l�构�Q�alter tableName ADD INDEX [indexName] ON (tableColumns(length))
      �Q?�Q�创��的时候直接指定：create TABLE tableName ( [...], INDEX [indexName] (tableColumns(length)) ;

    2.唯一索引�?
       它与前面�?普通烦�?�c�M��Q�不同的��是�Q�烦引列的值必��d��一�Q�但允许有空倹{��如果是�l�合索引�Q�则列值的�l�合必须唯一。它有以下几�U�创建方式：
       �Q?�Q�创建烦引：create UNIQUE INDEX indexName ON tableName(tableColumns(length))
      �Q?�Q�修改表�l�构�Q�alter tableName ADD UNIQUE [indexName] ON (tableColumns(length))
      �Q?�Q�创��的时候直接指定：create TABLE tableName ( [...], UNIQUE [indexName] (tableColumns(length));

     3.主键索引
        它是一�U�特�D�的唯一索引�Q�不允许有空倹{��一般是在徏表的时候同时创��Z��键烦引：create TABLE testIndex(i_testID INT NOT NULL AUTO_INCREMENT,vc_Name VARCHAR(16) NOT NULL,PRIMARY KEY(i_testID)); 当然也可以用alter命��o�?
       ��C��Q�一个表只能有一个主键�?

      4.全文索引
        MySQL�?.23.23版开始支持全文烦引和全文��索。这里不作讨论，呵呵~~

    删除索引的语法：drop INDEX index_name ON tableName

三、单列烦引和�l�合索引

    ��Z��形象地对比两者，再徏一个表�Q?
    create TABLE myIndex ( i_testID INT NOT NULL AUTO_INCREMENT, vc_Name VARCHAR(50) NOT NULL, vc_City VARCHAR(50) NOT NULL, i_Age INT NOT NULL, i_SchoolID INT NOT NULL, PRIMARY KEY (i_testID) );

    在这10000条记录里�?�?下地分布�?条vc_Name="erquan"的记录，只不�q�city,age,school的组合各不相同�?
来看�q�条T-SQL�Q?
    select i_testID FROM myIndex where vc_Name='erquan' AND vc_City='郑州' AND i_Age=25;

    首先考虑建单列烦引：
     在vc_Name列上建立了烦引。执行T-SQL�Ӟ��MYSQL很快��目标锁定在了vc_Name=erquan�?条记录上�Q�取出来攑ֈ�一中间�l�果集。在�q�个�l�果集里�Q�先排除掉vc_City不等�?郑州"的记录，再排除i_Age不等�?5的记录，最后筛选出唯一的符合条件的记录�?

    虽然在vc_Name上徏立了索引�Q�查询时MYSQL不用扫描整张表，效率有所提高�Q�但��L��们的要求�q�有一定的距离。同��L��Q�在vc_City和i_Age分别建立的单列烦引的效率�怼��?

    ��Z��q�一步榨取MySQL的效率，��p��考虑建立�l�合索引。就是将vc_Name,vc_City,i_Age建到一个烦引里�Q?
    alter TABLE myIndex ADD INDEX name_city_age (vc_Name(10),vc_City,i_Age);--注意了，��Ӟ��vc_Name长度�?0�Q�这里�ؓ什么用10呢？因�ؓ一般情况下名字的长度不会超�q?0�Q�这样会加速烦引查询速度�Q�还会减��烦引文件的大小�Q�提高insert的更新速度�?

    执行T-SQL�Ӟ��MySQL无须扫描��M��记录��到扑ֈ�唯一的记录！�Q?

     肯定有�h要问了，如果分别在vc_Name,vc_City,i_Age上徏立单列烦引，让该表有3个单列烦引，查询时和上述的组合烦引效率一样吧�Q�嘿嘿，大不一��P��q�远低于我们的组合烦引~~虽然此时有了三个索引�Q�但MySQL只能用到其中的那个它认�ؓ��g��是最有效率的单列索引�?

    建立�q�样的组合烦引，其实是相当于分别建立�?
        vc_Name,vc_City,i_Age
        vc_Name,vc_City
        vc_Name
    �q�样的三个组合烦引！��Z��么没有vc_City,i_Age�{�这��L��l�合索引呢？�q�是因�ؓmysql�l�合索引"最左前�~�"的结果。简单的理解��是只从最左面的开始组合。�ƈ不是只要包含�q�三列的查询都会用到该组合烦引，下面的几个T-SQL会用刎ͼ�
    select * FROM myIndex WHREE vc_Name="erquan" AND vc_City="郑州"
    select * FROM myIndex WHREE vc_Name="erquan"
而下面几个则不会用到�Q?
    select * FROM myIndex WHREE i_Age=20 AND vc_City="郑州"
    select * FROM myIndex WHREE vc_City="郑州"

四、��用烦�?
     到此你应该会建立、��用烦引了吧？但什么情况下需要徏立烦引呢�Q�一般来��_��在where和join中出现的列需要徏立烦引，但也不完全如此，因�ؓ MySQL只对 <�Q?lt;=�Q?�Q?gt;�Q?gt;=�Q�BETWEEN�Q�IN�Q�以及某些时候的like(后面有说�?才会使用索引�?
    select t.vc_Name FROM testIndex t LEFT join myIndex m ON t.vc_Name=m.vc_Name where m.i_Age=20 AND m.vc_City='郑州' �Ӟ��有对myIndex表的vc_City和i_Age建立索引的需要，�׃��testIndex表的vc_Name开出现在了join子句中，也有对它建立索引的必要�?

    刚才提到了，只有某些时候的like才需建立索引�Q�是的。因为在以通配�W?% �?_ 开头作查询�Ӟ��MySQL不会使用索引�Q�如
    select * FROM myIndex where vc_Name like'erquan%'
会��用烦引，�?
    select * FROM myIndex wheret vc_Name like'%erquan'
    ��׃��会��用烦引了�?

五、烦引的不��之处

    上面说了那么多烦引的好话�Q�它真的有像传说中那么优�U�么？当然会有�~�点了�?

    1.虽然索引大大提高了查询速度�Q�同时却会降低更新表的速度�Q�如对表�q�行insert、update和delete。因为更新表�Ӟ��MySQL不仅要保存数据，�q�要保存一下烦引文�?

    2.建立索引会占用磁盘空间的索引文�g。一般情况这个问题不太严重，但如果你在一个大表上创徏了多�U�组合烦引，索引文�g的会膨胀很快�?

    ��尾�Q?
    讲了�q�么多，无非是想利用索引提高数据库的执行效率。不�q�烦引只是提高效率的一个因素。如果你的MySQL有大数据的表�Q�就需要花旉��研究建立最优秀的烦引或优化查询语句�?

Frank_Fang 2009-07-25 00:11 发表评论

Frank_Fang — Fri, 24 Jul 2009 10:26:00 GMT
使用关系代数合�ƈ数据
1 关系代数
合�ƈ数据集合的理论基��是关�p�M��敎ͼ�它是由E.F.Codd�?970�q�提出的�?br /> 在关�p�M��数的形式化语�a�中：
        用表、或者数据集合表�C�关�p�L��者实体�?br />         用行表示元组�?br />          用列表示属性�?br /> 关系代数包含以下8个关�p�运��符
        选取――返回满��x��定条件的行�?br />          投媄――从数据集合中返回指定的列�?br />          �W�卡��积――是关系的乘法，它将分别来自两个数据集合中的行以所有可能的方式�q�行�l�合�?br />          �q�――关�pȝ��加法和减法，它可以在行的方向上合�q�两个表中的数据�Q�就像把一个表垒在另一个表之上一栗��?br />          交――返回两个数据集合所共有的行�?br />          差――返回只属于一个数据集合的行�?br />          �q�接――在水��^方向上合�q�两个表�Q�其�Ҏ��是：��两个表中在共同数据��上�怺�匚w��的那些行合�ƈ��h��?br />          除――返回两个数据集之间的精��匹配�?br /> 此外�Q�作��Z��U�实现现代关�p�M��数运��的�Ҏ��Q�SQL�q�提供了�Q?br />          子查询――类��g��q�接�Q�但更灵�z�；在外部查询中�Q�方式可以��用表辑ּ�、列表或者数据集合的地方都可以��用子查询的结果�?br /> 本章��主要讲�q�多�U�类型的�q�接、简单的和相关的子查询、几�U�类型的�q�、关�p�除以及其他的内宏V�?br /> 2 使用�q�接
2.1 �q�接�c�d��
在关�p�M��C��Q�连接运��是�׃��个笛卡尔�U�运��和一个选取�q�算构成的。首先用�W�卡��积完成对两个数据集合的乘运��，然后对生成的�l�果集合�q�行选取�q�算�Q�确�?只把分别来自两个数据集合�q�且��h��重叠部分的行合�ƈ在一赗��连接的全部意义在于在水�q�x��向上合�ƈ两个数据集合�Q�通常是表�Q�，�q��生一个新的结果集合，其方法是��一个数据源中的行于另一个数据源中和它匹配的行组合成一个新元组�?br /> SQL提供了多�U�类型的�q�接方式�Q�它们之间的区别在于�Q�从�怺�交叠的不同数据集合中选择用于�q�接的行时所采用的方法不同�?br /> �q�接�c�d��         定义
内连�?nbsp;        只连接匹配的�?br /> 左外�q�接         包含左边表的全部行（不管双��的表中是否存在与它们匚w��的行�Q�，以及双��表中全部匚w��的行
叛_��q�接         包含双��表的全部行（不管左边的表中是否存在与它们匚w��的行�Q�，以及左边表中全部匚w��的行
全外�q�接         包含左、右两个表的全部行，不管另外一边的表中是否存在与它们匹配的行�?br /> (H)(theta)�q�接         使用�{��g��外的条�g来匹配左、右两个表中的行
交叉�q�接         生成�W�卡��积�Q�它不��用�Q何匹配或者选取条�g�Q�而是直接��一个数据源中的每个行与另一个数据源的每个行都一一匚w��
在INFORMIX中连接表的查�?br /> 如果FROM子句指定了多于一个表引用�Q�则查询会连接来自多个表的行。连接条件指定各列之��_��每个表至��一列）�q�行�q�接的关�p�R��因为正在比较连接条件中的列�Q�所以它们必��d��有一致的数据�c�d��?br /> SELECT语句的FROM子句可以指定以下几种�c�d��的连�?br /> FROM子句关键�?nbsp;        相应的结果集
CROSS JOIN         �W�卡��乘�U�（所有可能的行对�Q?br /> INNER JOIN         仅对满��q�接条�g的CROSS中的�?br /> LEFT OUTER JOIN         一个表满��条�g的行�Q�和另一个表的所有行
RIGHT OUTER JOIN         �?strong style="color: black; background-color: rgb(255,255,102)">LEFT相同�Q�但两个表的角色互换
FULL OUTER JOIN        LEFT OUTER �?RIGHT OUTER中所有行的超�?br />
2.2 内连接（Inner Join�Q?br /> 内连接是最常见的一�U�连接，它页被称为普通连接，而E.FCodd最早称之�ؓ自然�q�接�?br /> 下面是ANSI SQL�Q?2标准
select *
from   t_institution i
inner join t_teller t
on i.inst_no = t.inst_no
where i.inst_no = "5801"
其中inner可以省略�?br /> �{��h于早期的�q�接语法
select *
from t_institution i, t_teller t
where i.inst_no = t.inst_no
and i.inst_no = "5801"

2.3 外连�?br /> 2.3.1         左外�q�接(Left Outer Jion)
select *
from   t_institution i
left outer join t_teller t
on i.inst_no = t.inst_no
其中outer可以省略�?br /> 2.3.2         叛_��q�接(Rigt Outer Jion)
select *
from   t_institution i
right outer join t_teller t
on i.inst_no = t.inst_no
2.3.3         全外�q�接(Full Outer)
全外�q�接�q�回参与�q�接的两个数据集合中的全部数据，无论它们是否��h��与之相匹配的行。在功能上，它等价于对这两个数据集合分别�q�行左外�q�接和右外连接，然后再��用消去重复行的�ƈ操作��上�q�C��个结果集合�ƈ��Z��个结果集�?br /> 在现实生�z�M��Q�参照完整性约束可以减��对于全外连接的使用�Q�一般情况下左外�q�接��p��够了。在数据库中没有利用清晰、规范的�U�束来防范错误数据情况下�Q�全外连接就变得非常有用了，你可以��用它来清理数据库中的数据�?br /> select *
from   t_institution i
full outer join t_teller t
on i.inst_no = t.inst_no
2.3.4         外连接与条�g配合使用
当在内连接查询中加入条�g是，无论是将它加入到join子句�Q�还是加入到where子句�Q�其效果是完全一��L��Q�但对于外连接情况就不同了。当把条件加入到join�?句时�Q�SQL Server、Informix会返回外�q�接表的全部行，然后使用指定的条件返回第二个表的行。如果将条�g攑ֈ�where子句中，SQL Server��会首先�q�行�q�接操作�Q�然后��用where子句对连接后的行�q�行�{�选。下面的两个查询展示了条件放�|�位子对执行�l�果的媄响：
条�g�?strong style="color: black; background-color: rgb(153,255,153)">join子句
select *
from   t_institution i
left outer join t_teller t
on i.inst_no = t.inst_no
and i.inst_no = “5801”
�l�果是：
inst_no     inst_name             inst_no     teller_no   teller_name
5801        天河�?nbsp;               5801        0001        tom
5801        天河�?nbsp;               5801        0002        david
5802        ��秀�?br /> 5803        白云�?br /> 条�g在where子句
select *
from   t_institution i
left outer join t_teller t
on i.inst_no = t.inst_no
where i.inst_no = “5801”
�l�果是：
inst_no     inst_name             inst_no     teller_no   teller_name
5801        天河�?nbsp;               5801        0001        tom
5801        天河�?nbsp;               5801        0002        david

2.4 自��n�q�接
自��n�q�接是指同一个表自己与自��p��行连接。这�U�一元连接通常用于从自反关�p�（也称作递归关系�Q�中抽取数据。例如�h力资源数据库中雇员与老板的关�p�R�?br /> 下面例子是在机构表中查找本机构和上��机构的信息�?br /> select s.inst_no superior_inst, s.inst_name sup_inst_name, i.inst_no, i.inst_name
from t_institution i
join t_institution s
on i.superior_inst = s.inst_no

�l�果是：
superior_inst sup_inst_name         inst_no     inst_name
800            �q�州�?nbsp;               5801        天河�?br /> 800            �q�州�?nbsp;               5802        ��秀�?br /> 800            �q�州�?nbsp;               5803        白云�?br />
2.5 交叉(无限�? �q�接
交叉�q�接用于对两个源表进行纯关系代数的乘�q�算。它不��用连接条件来限制�l�果集合�Q�而是��分别来自两个数据源中的行以所有可能的方式�q�行�l�合。数据集合中一的每个行都要与数据集合二中的每一个行分别�l�成一个新的行。例如，如果�W�一个数据源中有5个行�Q�而第二个数据源中�?个行�Q�那么在它们之间�q�行交叉�q�接 ��׃��产生20个行。�h们将�q�种�c�d��的结果集�U�Cؓ�W�卡��乘�U��?br /> 大多��C��叉连接都是由于错误操作而造成的；但是它们却非帔R��合向数据库中填充例子数据，或者预先创��Z��些空行以便�ؓ�E�序执行期间所要填充的数据保留�I�间�?br /> select *
from   t_institution i
cross join t_teller t
在交叉连接中没有on条�g子句

Frank_Fang 2009-07-24 18:26 发表评论

Frank_Fang — Tue, 30 Jun 2009 13:06:00 GMT
以及如何用Hibernate来��?

Frank_Fang 2009-06-30 21:06 发表评论

Frank_Fang — Sun, 03 May 2009 12:09:00 GMT
     摘要: 1 package edu.b.recommender.actions; 2 3 import org.apache.struts2.convention.annotation.Action; 4 import org.apache.struts2.convention.a...  阅读全文

Frank_Fang 2009-05-03 20:09 发表评论

Frank_Fang — Sun, 03 May 2009 11:59:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/fhtdy2004/archive/2009/05/03/268718.html'>阅读全文

Frank_Fang 2009-05-03 19:59 发表评论

SSH整合配置

Frank_Fang — Sun, 03 May 2009 11:42:00 GMT

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
    default-lazy-init="true">

    <description>Spring公共配置文�g description>


    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
        <property name="ignoreResourceNotFound" value="true" />

        <property name="locations">
            <list>

                <value>classpath*:/application.propertiesvalue>

                <value>classpath*:/application.local.propertiesvalue>


            list>
        property>
    bean>





    <context:component-scan base-package="edu.b.recommender" />


    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />


        <property name="initialSize" value="5" />
        <property name="maxActive" value="100" />
        <property name="maxIdle" value="30" />
        <property name="maxWait" value="1000" />
        <property name="poolPreparedStatements" value="true" />
        <property name="defaultAutoCommit" value="false" />
    bean>





    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="namingStrategy">
            <bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
        property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}prop>
                <prop key="hibernate.use_outer_join">${hibernate.use_outer_join}prop>
                <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}prop>
                <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}prop>
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}prop>

                <prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.ehcache_config_file}prop>
            props>
        property>

        <property name="packagesToScan" value="edu.b.recommender.*" />
    bean>



    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    bean>






    <tx:annotation-driven transaction-manager="transactionManager" />
beans>

Frank_Fang 2009-05-03 19:42 发表评论

Spring自动扫描classpath,及po is not mapped问题解决

Frank_Fang — Sun, 03 May 2009 11:39:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/fhtdy2004/archive/2009/05/03/268714.html'>阅读全文

Frank_Fang 2009-05-03 19:39 发表评论

Frank_Fang — Sun, 03 May 2009 11:24:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/fhtdy2004/archive/2009/05/03/268713.html'>阅读全文

Frank_Fang 2009-05-03 19:24 发表评论

Struts2入门学习

Frank_Fang — Sun, 03 May 2009 11:21:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/fhtdy2004/archive/2009/05/03/268712.html'>阅读全文

Frank_Fang 2009-05-03 19:21 发表评论

struts2 struts.xml配置文�g详解mark

Frank_Fang — Sun, 03 May 2009 11:15:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://www.tkk7.com/fhtdy2004/archive/2009/05/03/268711.html'>阅读全文

Frank_Fang 2009-05-03 19:15 发表评论

Frank_Fang — Wed, 29 Apr 2009 01:13:00 GMT
Struts2 + jQuery 实现完成��h��Q�不做页面蟩转的ajax效果

需求要求实现用弹出层发送邮件。提交后层关闭，�E�序再服务器端响应�?/p>

JSON插�g提供了一�U�名为json的ResultType�Q�一旦�ؓ某个Action指定了一个类型�ؓjson的Result�Q�则该Result无需映射��C�Q何视图资源。因为JSON插�g会负责将Action里的状态信息序列化成JSON格式的数据，�q�将该数据返回给客户端页面的JavaScript �?/p>

��单地��_��JSON插�g允许我们在JavaScript中异步调用Action�Q�而且Action不再需要��用视图资源来昄��该Action里的状态信息，而是由JSON插�g负责��Action里的状态信息返回给调用��面——通过�q�种方式�Q�就可以完成Ajax交互�?br />
1、将struts2的json插�g加入web工程的lib�Q�jsonplugin的下载地址�Q?a target="_blank">http://code.google.com/p/jsonplugin/downloads/list

2、struts.xml��d��专�ؓajax使用的package

<package name="ajax" extends="json-default">
        <action name="ajaxRequest" class="org.david.struts2.HelloWorld">
            <result type="json">result>
        action>
package>

3、在��面中引�?nbsp;jquery的js文�g�?/span>

    <SCRIPT type="text/javascript" src="js/jquery-1.2.6.min.js">script>
<SCRIPT type="text/javascript">
            function clickButton()
            {
                var url = 'ajaxRequest.action';
                var params = {
                        name:$('#name').attr('value'),
                           contactEmail:$('#contactEmail').attr('value'),
                           subject:$('#subject').attr('value'),
                           content:$('#content').attr('value')

                      }; //通过id获得输入�?br />                  jQuery.post(url, params, callbackFun, 'json');



               } //url�Q�响应aciton�Q�params�Q�传入参敎ͼ�callbackFun�Q�响应完成后的回调函敎ͼ�


               function callbackFun(data)
            {
                 alert("SUCCESS");
                }
     SCRIPT>

4、action逻辑与普通的ation写法无大区别�?/span>

     JSON��Action里的状态信息序列化成JSON格式的数�?/span>

Frank_Fang 2009-04-29 09:13 发表评论

	Dirty Read	NonRepeatabe Read	Phantom Read
Read uncommitted	Possible	Possible	Possible
Read committed	not possible	Possible	Possible
Repeatabe read	not possible	not possible	Possible
Seriaizabe	not possible	not possible	not possible