1、首先在入口文件中关闭调试模式

// 开启调试模式 建议开发阶段开启True 部署阶段注释或者设为false
define('APP_DEBUG',false);
2、修改 Conf/config.php

// 异常页面的模板文件
    'TMPL_EXCEPTION_FILE'   =>  THINK_PATH.'Tpl/show_error.tpl',

3、修改相应的模板文件

改为自己想要的报错页面即可


PS:如果遇到错误，请查看日志

                                        
                                            

	一、环境： linux redhat 5.8


	                   oracle 11.2.0.4.0


	二、问题描述：


	       有个用户密码忘记了，又怕改了该用户密码会影响应用，因为改密码很容易，如果影响的话该何所做好回退方案呢。以下就是我的回退方案。


	


	三、实验证明：


	1. 建立测试用户并赋权限


					

						[oracle@tora01 ~]$ sqlplus / as sysddba
					
					

						

					

						SQL*Plus: Release 11.2.0.4.0 Production on Tue Jul 28 11:48:33 2015
					
					

						

					

						Copyright (c) 1982, 2013, Oracle.  All rights reserved.
					
					

						

					

						Connected to:
					
					

						Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production
					
					

						With the Partitioning, OLAP, Data Mining and Real Application Testing options
					
					

						

					

						SQL> create user sam identified by sam;
					
					

						

					

						User created.
					
					

						

					

						SQL> grant connect to sam;
					
					

						

					

						Grant succeeded.
					


			



	2. 记录用户密码与SPARE4字段的值，通过惜分飞的博客得知SPARE4字段是密码大小写敏感控制《http://www.xifenfei.com/4396.html》。此处我的实验是要求记录此值，为了后面恢复密码使用。

					

						SQL> set lines 200
					
					

						SQL> col passwrod for a20
					
					

						SQL> col spare4 for a70
					
					

						SQL> select password,spare4 from user$ where name='SAM';
					
					

						

					

						PASSWORD             SPARE4
					
					

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

						4B95138CB6A4DB94     S:DD85639AB2542CB45E1138F8570E837C95555A337D60752453848A22F1E9
					


			



	3. 使用命令方式修改密码

					

						SQL> alter user sam identified by Oracle;
					
					

						

					

						User altered.
					


			




	


	4. 再次检查基表情况

					

						SQL> select password,spare4 from user$ where name='SAM';
					
					

						

					

						PASSWORD             SPARE4
					
					

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

						25CA928B1DB71583     S:CF85AA4FA2DA01D1FC0B0C7C540C9A49A966A638302DC007AF1B2481CD5B
					


			



	


	5. 测试用户用新密码登录


	

					

						SQL> conn sam/Oracle;
					
					

						Connected.
					


			




	6. 修改基表，使得变更回改前密码


	

					

						SQL> conn / as sysdba
					
					

						Connected.
					
					

						SQL> update user$ set password='4B95138CB6A4DB94' where name='SAM';
					
					

						

					

						1 row updated.
					
					

						

					

						SQL> update user$ set spare4='S:DD85639AB2542CB45E1138F8570E837C95555A337D60752453848A22F1E9' where name='SAM';
					
					

						

					

						1 row updated.
					
					

						

					

						SQL> commit;
					
					

						

					

						Commit complete.
					


			



	7. 清理shared_pool

					

						SQL> alter system flush shared_pool;
					
					

						

					

						System altered.
					


			



	8. 测试用原来的密码连接，成功


	

					

						SQL> conn sam/sam;
					
					

						Connected.
					


			



	四、总结


	该方法由于对基表进行修改，不建议轻易使用，由其是生产环境，最好的方法还是要在文档中记录用户密码。在忘记时可以通过文档查找。


	


	



                                                            

                    

                                                    来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/26148431/viewspace-1754165/，如需转载，请注明出处，否则将追究法律责任。
                                            

                
转载于:http://blog.itpub.net/26148431/viewspace-1754165/




SQL Server
的事务和锁（举例）


原料：创建Test表

CREATE
TABLE [dbo].[Test](

   
[id] [int] NULL,

   
[name] [nchar](10)
COLLATEChinese_PRC_CI_AS 
NULL,

   
[info] [nchar](10)
COLLATEChinese_PRC_CI_AS 
NULL


)
ON [PRIMARY]


插入一条记录


INSERT
INTO Test VALUES(2,'kk',null)


查询显示有此记录


SELECT * FROM Test  Where
name='kk'


id  name   info


1   kk      NULL


 


【测试一：丢失更新】


--事务1  

begin
tran  

select
* from dbo.Test(nolock)
where name 
= 'kk'  

waitfor delay
'00:00:05'  

update T
set info = 
'A更改'
from Test T(nolock)
where name 
= 'kk'

commit
tran  


--事务2  

begin
tran  

   
select *from dbo.Test(nolock)
where name 
= 'kk'  

   
waitfor delay '00:00:05' 


   
update T setinfo
= 'B更改'
from Test T(nolock)
where name 
= 'kk'   


commit
tran  --事务1


begintran


  
select * from dbo.Test(nolock) where name ='kk'


  
waitfor delay '00:00:05'


  
update T set info = 'A更改' from Test T(nolock)where name = 'kk'


committran


 


--事务2


begintran


  
select * from dbo.Test(nolock) where name ='kk'


  
waitfor delay '00:00:05'


  
update T set info = 'B更改' from Test T(nolock)where name = 'kk'


committran


 


事务1和事务2的运行结果：


id  name   info


1   kk      NULL


 


事务结束最后结果：


SELECT
* FROM 
Test  Wherename='kk'


id  name   info


1   kk      B更改


 


说明：【事务1】更改了数据，但是没有被读到。最终【事务2】的更改覆盖了【事务1】的更改值


 


解决：允许对事务操作加锁，即取消(nolock)，nolock级别最低。


 


当前使用：SET
TRANSACTION ISOLATION
LEVEL READ UNCOMMITTED


（READ UNCOMMITTED：即未提交的数据只能读取，不能更改）


 


 


【测试二：脏读】


--事务1  

SET
TRANSACTION ISOLATION
LEVEL READ UNCOMMITTED

begin
tran  

update T
set info = 
'A更改'
from Test T where
name = 
'kk'

waitfor delay
'00:00:05'  

rollback
tran  


--事务2  

SET
TRANSACTION ISOLATION
LEVEL READ UNCOMMITTED


begin
tran  

   
select *from dbo.Test
where name 
= 'kk'  


commit
tran  --事务1


begintran


  
select * from dbo.Test(nolock) where name ='kk'


  
waitfor delay '00:00:05'


  
update T set info = 'A更改' from Test T(nolock)where name = 'kk'


committran


 


--事务2


begintran


  
select * from dbo.Test(nolock) where name ='kk'


  
waitfor delay '00:00:05'


  
update T set info = 'B更改' from Test T(nolock)where name = 'kk'


committran


 


 


--事务1



SETTRANSACTION ISOLATION LEVEL READ UNCOMMITTED


begintran


  
update T set info = 'A更改' from Test T where name= 'kk'


  
waitfor delay '00:00:05'


rollbacktran --回滚


 


--事务2


SETTRANSACTION ISOLATION LEVEL READ UNCOMMITTED


begintran


  
select * from dbo.Test where name = 'kk'


committran


 


事务2的运行结果：


id  name   info


1   kk      A更改


 


事务结束最后结果：


SELECT
* FROM 
Test  Wherename='kk'


id  name   info


1   kk      NULL


 


说明：【事务1】更改了数据，【事务2】读取了表中更改的值，【事务1】回滚。最终的表是没有被更改的。


 


解决一：提高隔离级别


SET
TRANSACTION ISOLATIONLEVEL
READCOMMITTED


ALTER
DATABASEDBNameSETREAD_COMMITTED_SNAPSHOTOFF（默认OFF）


此时【事务1】等待事务【事务2】完成后才读取表中的值。


（READ COMMITTED：更改的数据只能是提交后才能读取）


 


解决二：


SET
TRANSACTION ISOLATION LEVEL READ COMMITTED


ALTER
DATABASEDBNameSETREAD_COMMITTED_SNAPSHOTON（默认OFF）


此时【事务2】读到的是表中之前的快照值（不必等待【事务1】完成）。


此时相当于：


SET
TRANSACTION ISOLATIONLEVEL
READCOMMITTED


select
* from 
dbo.Test WITH(READPAST)
where
name='kk'


 


解决三：


事务2用表提示READ
 COMMITTED LOCK把语句级别改为READ COMMITTED


--事务2

SET
TRANSACTION ISOLATION
LEVEL READ UNCOMMITTED

begin
tran

   
select *from dbo.Test
WITH(READCOMMITTEDLOCK)where
name='kk'

commit
tran


 


如果将
READ_COMMITTED_SNAPSHOT设置为OFF（默认设置），设置时关闭所有对此数据库的连接，


数据库引擎会使用共享锁防止其他事务在当前事务执行读取操作期间修改行。


共享锁还会阻止语句在其他事务完成之前读取由这些事务修改的行。


 


 


 


【测试三：不可重读】


 


--事务1  

SET
TRANSACTION ISOLATION
LEVEL READ COMMITTED 

   
begin tran 


   
select *from dbo.Test
where name 
= 'kk'  

   
waitfor delay '00:00:05' 


   
select *from dbo.Test
where name 
= 'kk'  

commit
tran   


--事务2  

SET
TRANSACTION ISOLATION
LEVEL READ COMMITTED 

   
begin tran 


   
update T setinfo
= 'B更改'
from Test T where
name = 
'kk'  


commit
tran 


--事务1


SETTRANSACTION ISOLATION LEVEL READ COMMITTED


begintran


  
select * from dbo.Test where name = 'kk'


  
waitfor delay '00:00:05'


  
select * from dbo.Test where name = 'kk'


committran 


 


--事务2


SETTRANSACTION ISOLATION LEVEL READ COMMITTED


begintran


  
update T set info = 'B更改' from Test T where name= 'kk'


committran


 


事务2的运行结果：


id  name   info


1   kk      NULL


 


id  name   info


1   kk      B更改


 


事务结束最后结果：


SELECT
* FROM 
Test  Wherename='kk'


id  name   info


1   kk      B更改


 


说明：【事务1】读取了数据，【事务2】更改数据，【事务1】再读取数据。【事务1】两次读取都不一样！


 


解决一：提高隔离级别


SET
TRANSACTION ISOLATIONLEVEL REPEATABLE
READ


（REPEATABLE READ：允许重复读取数据，但读取的都是第一次读取的副本）


 


解决二：更改为快照级别


ALTER
DATABASE DBName SETALLOW_SNAPSHOT_ISOLATIONON


SET
TRANSACTION ISOLATION LEVEL SNAPSHOT


 


此时【事务1】的运行结果2次都一样，读到的都是未更改前的值：


id  name   info


1   kk      NULL


 


 


 


【测试四：幻读】


--事务1   

SET
TRANSACTION ISOLATION
LEVEL REPEATABLEREAD

begin
tran  

   
select *from dbo.Test
where name 
= 'kk'  

   
waitfor delay '00:00:05'
 

   
select *from dbo.Test
where name 
= 'kk'  

commit
tran  

   
  


--事务2  

SET
TRANSACTION ISOLATION
LEVELREPEATABLE READ

begin
tran  

   
INSERT INTOTest
VALUES(2,'kk',null)  



commit
tran  --事务1



SETTRANSACTION ISOLATION LEVEL SERIALIZABLE


begintran


  
select * from dbo.Test where name = 'kk'


  
waitfor delay '00:00:05'


  
select * from dbo.Test where name = 'kk'


committran


 


--事务2


SETTRANSACTION ISOLATION LEVEL SERIALIZABLE


begintran


  
INSERT INTO Test VALUES(2,'kk',null) 


committran


 


事务2的运行结果：


id  name   info


1   kk      NULL


 


id  name   info


1   kk      NULL


2   kk      NULL


 


事务结束最后结果：


SELECT
* FROM 
Test  Wherename='kk'


id  name   info


1   kk      NULL


2   kk      NULL


 


说明：【事务1】读取了数据，【事务2】插入了数据，【事务1】再读取数据。【事务1】两次读取都不一样！幻觉？


 


解决：提高隔离级别


SET
TRANSACTION ISOLATIONLEVEL SERIALIZABLE 


此时【事务2】等待【事务1】完成。


事务1的运行结果2次都一样：


id  name   info


1   kk      NULL


 


范围锁：范围锁处于与事务中执行的每个语句的搜索条件相匹配的键值范围之内。这样可以阻止其他事务更新或插入任何行，从而限定当前事务所执行的任何语句。这意味着如果再次执行事务中的任何语句，则这些语句便会读取同一组行。在事务完成之前将一直保持范围锁。这是限制最多的隔离级别，因为它锁定了键的整个范围，并在事务完成之前一直保持范围锁。因为并发级别较低，所以应只在必要时才使用该选项。该选项的作用与在事务内所有SELECT语句中的所有表上设置HOLDLOCK相同。


 


 


如果在批处理中设置
REPEATABLE 
READ，并且该批处理调用一个将隔离级别设置为SERIALIZABLE的存储过程，则当该存储过程将控制返回给该批处理时，隔离级别就会恢复为REPEATABLEREAD。


 





并发事务引起的问题






     
问题          




                   
描述                      




             
结果             




                         
解决                     






丢失更新




A读—B读—A改—B改




A更改丢失




READ UNCOMMITTED






脏读




A改—B读—A回滚




B读无效值




READ COMMITTED






不可重读




A读—B改—A读




A读不一致




REPEATABLE READ






不可重读




A读—B改—A读




A读不一致




SNAPSHOT






幻读




A读—B增删—A读




A读或多或少




SERIALIZABLE




 

    以前在预测到的位置开枪后没打中敌人的话，我还会守在那里再打。就是为了防止敌人因为要对付我的预测而停顿一回合。守在那个地方打到底对于敌人的反预测有没有效果我不知道，因为我一直以来都在拿疯狂坦克作为我改进的对象。结果我发现对于疯狂坦克，这样的战术不但没作用（理所当然，疯狂坦克没有预测，也没有反预测），反而使得我过多火力浪费在空地上，没有去抢矿也没有去打敌人。于是我把预测到的敌人位置中没打中的去掉，不再守住那个地方打，这样一改竟然效果挺好。比赛最初发布的6张地图，红蓝双方分别来一次共12次，之前我最多8:4赢了疯狂，改了后我就11:1赢了，当然此时我不再是全部Sniper了，加了Pioneer进去。
    对于Pioneer的碾压，我是当他一定能压毁对方（不管我挂不挂）就压，这样导致在跟敌人对战的时候容易浪费生命值。具体就是当我跟敌人距离为1时，敌人开火，此时我去压的话，系统先判断开火打中我，然后我再移动去压他，于是我多浪费一个生命值。所以其实即使我能压死他，我也不应该直接去压，有可能攻击他倒是更好。但是对于Striker，Pioneer就要尽量少跟他对战，因为Striker攻击力是2，Pioneer是1。 于是总结成这样，Pioneer跟敌方距离为1的时候，如果敌方是生命值大于等于2的Striker，那么我直接压他（虽然我可能会因此被他打中一枪，但比他打中两枪以上要好），否则我不压，跟他对战。改了这个以后我跟疯狂的战绩是红方全胜（前面11:1的那场输的就是作为红方的一场），而且以前赢的现在赢得更多些。蓝方没时间测了，回实验室还有事情。
    这几天脑子里面想着坦克的事情，实验室的事情都跟不上了，18号有一个报告，我心理面有点担忧了。因为报告的内容，我根本就没有头绪了，还叫我做一个filter的大总结。。。 坦克好像时限有点问题，等我把实验室的事情忙完了，再到Linux下面跑一下看正不正常。昨天晚上在VMWare下面装了RedHat9，结果跑坦克的程序的时候竟然提示我libstdc++.so.6找不到。后来看到网上有人说RedHat停止RedHat9的更新了。。。 于是想与其更新RedHat9的库（我想象中是很麻烦），还不如重装个更高级一点的。好在室友说他有Ubuntu 8，过几天给他借来装。
    坦克搞得我脑子有点混沌。
 
 
    本来想在百度空间发表的，竟然说
 
对不起，您的文章发表失败。

文章内容包含不合适内容，请检查
    我搞不懂了。发到这里来。