tbwshc

Java调用SQL Server的存储过程详解

1使用不带参数的存储过程

　　1

　　{call procedure-name}

　　作为实例，在 SQL Server 2005 AdventureWorks 示例数据库中创建以下存储过程：

　　CREATE PROCEDURE GetContactFormalNames

　　AS BEGIN SELECT TOP 10 Title + ' ' + FirstName + ' ' + LastName AS FormalName

　　FROM Person.Contact END

　　此存储过程返回单个结果集，其中包含一列数据(由 Person.Contact 表中前十个联系人的称呼、名称和姓氏组成)。

　　在下面的实例中，将向此函数传递 AdventureWorks 示例tb数据库的打开连接，然后使用 executeQuery 方法调用 GetContactFormalNames 存储过程。

　　public static void executeSprocNoParams(Connection con)

　　…{

　　try …{

　　Statement stmt = con.createStatement();

　　ResultSet rs = stmt.executeQuery("{call dbo.GetContactFormalNames}");

　　while (rs.next())

　　…{

　　System.out.println(rs.getString("FormalName"));

　　}

　　rs.close();

　　stmt.close();

　　}

　　catch (Exception e)

　　…{

　　e.printStackTrace();

　　}

　　}

　　2使用带有输入参数的存储过程

　　使用 JDBC 驱动程序调用带参数的存储过程时，必须结合 SQLServerConnection 类的 prepareCall 方法使用 call SQL 转义序列。带有 IN 参数的 call 转义序列的语法如下所示：

　　{call procedure-name[([parameter][,[parameter]]…)]}http://jie.baijiale.94ibc.com

　　构造 call 转义序列时，请使用 ?(问号)字符来指定 IN 参数。此字符充当要传递给该存储过程的参数值的占位符。可以使用 SQLServerPreparedStatement 类的 setter 方法之一为参数指定值。可使用的 setter 方法由 IN 参数的数据类型决定。

　　向 setter 方法传递值时，不仅需要指定要在参数中使用的实际值，还必须指定参数在存储过程中的序数位置。例如，如果存储过程包含单个 IN 参数，则其序数值为 1.如果存储过程包含两个参数，则第一个序数值为 1,第二个序数值为 2.

　　作为如何调用包含 IN 参数的存储过程的实例，使用 SQL Server 2005 AdventureWorks 示例数据库中的 uspGetEmployeeManagers 存储过程。此存储过程接受名为 EmployeeID 的单个输入参数

posted @ 2013-10-24 17:05 chen11-1 阅读(615) | 评论 (0) | 编辑 收藏

Java中生成文件的10项建议

1. 记住 - "越少越好"并非总是如此(Keep in Mind – "Less is more" is not always better)。 – 高效率的代码是件好事，但很多情况下，并非代码行数越少效率就越高

　　2. 不要把简单事情复杂化(Do not complicate things)。 – 我曾经这么做过，我相信你也一样。开发者都倾向于采用复杂方式解决简单问题。我们在一个只有5个用户的系统中引入EJB,为一个并不需要框架的应用实现一套框架，采用属性文件、采用面向tb对象解决方案、使用线程，而这些根本用不着。为什么会这么做？一些人可能不知道有更好的解决方案，但另一些人可能故意这样做来学习新知识，或仅仅是因为有趣。对那些不知道更好解决方案的人，要多听有经验程序员的建议。对于那些纯粹出于个人目的而将设计复杂化的人，我建议你要更加专业一点。
　　3. 不要"硬编码"(No hard coding please)。 – 由于时间紧迫，开发者总是会忘记或故意忽略这一条。然而另一种可能是，遵循这条戒律，我们就不会陷入"时间紧迫"的困境。定义一个static final 变量，增加一行代码，又能花多长时间呢？

　　4. 为代码添加注释(Add comments to your code)。 – 每个人都知道这一点，但不是每个人都会这么做。你有多少次"忘记"添加注释了？确实，注释不会为你的程序增加任何函数功能。但是，有多少次，看到2周前写的代码，你都记不起它是干什么的？你很幸运，那些未注释的代码是你自己写的，你脑海中还会有残存的印象。非常不幸，大多时候，代码是别人写的，并且那个人很可能已经离开公司了。有句谚语说的好："有来有往，互惠互利",因此程序员应该体谅彼此(还有你自己)，给你的代码加上注释。

 

posted @ 2013-10-24 17:04 chen11-1 阅读(312) | 评论 (0) | 编辑 收藏

针对Java Excel API及详细教程

时在java开发中会操作excel表格，其实操作起来也特别简单。这里把前期操作步骤说一下，本文会简单的介绍一个开放源码项目：Java Excel Api，使用它大家就可以方便的操作Excel文件了。

　　首先下载好：Java Excel Api，这个文件我已经和 JAVA+Excel+API详细教程。pdf一并压缩上传了，感兴趣的朋友可以下载!

　　我这里用的开发平台是Eclipse，这里我把操作简单说一下：

　　1， 建，立java项目，在这个项目在建立一个新的文件夹lib;

　　2， 将jxl.jar，即Java Excel Ap，复制到lib

　　3，然后右键点击这个java项目，tb选择Propertieshttp://jie.baijiale.ibc198.com

　　4，在左侧列表里选中Java Build Path ，右侧选中Libraries

　　5，点击Add JARs

　　6， 然后去选择这个项目中lib文件夹中的jxl.jar，点击确定

　　成功后，项目中会多一个文件夹为：Referenced Libraries

　　准备工作完成后，就可以去操作excel了，

posted @ 2013-10-24 17:02 chen11-1 阅读(276) | 评论 (0) | 编辑 收藏

框架Quart在Java中任务调度的使用

  Quartz框架是一个全功能、开源的任务调度服务，可以集成几乎任何的java应用程序—从小的单片机系统到大型的电子商务系统。Quartz可以执行上千上万的任务调度。

　　核心概念

　　Quartz核心的概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节

　　Job任务：其实Job是接口，其中只有一个execute方法：

　　package org.quartz;

　　public abstract interface Job

　　{

　　public abstract void execute(JobExecutionContext paramJobExecutionContext)

　　throws JobExecutionException;

　　}

　　我们开发者只要实现此接口，实现execute方法即可。把我们想做的事情，在execute中执行即可。

　　JobDetail：任务细节，Quartz执行Job时，需要新建个Job实例，但是不能直接操作Job类，所以通过JobDetail来获取Job的名称、描述信息。

　　Trigger触发器：执行任务的规则;比如每天，每小时等。

　　一般情况使用SimpleTrigger，和CronTrigger，这个触发器实现了Trigger接口。

　　对于复杂的时间表达式来说，比如每个月15日上午几点几分，使用CronTrigger

　　对于简单的时间来说，比如每天执行几次，使用SimpleTrigger

　　scheduler任务调度：是最核心的概念，需要把JobDetail和Trigger注册到scheduler中，才可以执行。

　　注意：

　　不同的版本的jar包，具体的操作不太相同，但是tbw思路是相同的;比如1.8.6jar包中，JobDetail是个类，直接通过构造方法与Job类关联。SimpleTrigger和CornTrigger是类;在2.0.2jar包中，JobDetail是个接口，SimpleTrigger和CornTrigger是接口

　　不同版本测试：

　　1.8.6jar包：

　　[html]

　　package com.test;

　　import java.util.Date;

　　import org.quartz.Job;

　　import org.quartz.JobExecutionContext;

　　import org.quartz.JobExecutionException;

　　/**

　　* 需要执行的任务

　　* @author lhy

　　*

　　*/

　　public class MyJob implements Job {

　　@Override

　　//把要执行的操作，写在execute方法中

　　public void execute(JobExecutionContext arg0) throws JobExecutionException {

　　System.out.println("测试Quartz"+new Date());

　　}

　　}

　　package com.test;

　　import java.util.Date;

　　import org.quartz.Job;

　　import org.quartz.JobExecutionContext;

　　import org.quartz.JobExecutionException;

　　/**

　　* 需要执行的任务

　　* @author lhy

　　*

　　*/

　　public class MyJob implements Job {

　　@Override

　　//把要执行的操作，写在execute方法中

　　public void execute(JobExecutionContext arg0) throws JobExecutionException {

　　System.out.println("测试Quartz"+new Date());

　　}

　　}

　　使用SimpleTrigger触发器

　　[html]

　　package com.test;

　　import java.util.Date;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleTrigger;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class SchedulerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类

　　JobDetail jobDetail=new JobDetail("job1", "jgroup1", MyJob.class);

　　// 定义调度触发规则，比如每1秒运行一次，共运行8次

　　SimpleTrigger simpleTrigger=new SimpleTrigger("simpleTrigger","triggerGroup");

　　// 马上启动

　　simpleTrigger.setStartTime(new Date());

　　// 间隔时间

　　simpleTrigger.setRepeatInterval(1000);

　　// 运行次数

　　simpleTrigger.setRepeatCount(8);

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(jobDetail, simpleTrigger);

　　// 启动调度

　　scheduler.start();

　　}catch(SchedulerException e){

　　e.printStackTrace();

　　}

　　}

　　}

　　package com.test;

　　import java.util.Date;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleTrigger;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class SchedulerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类
　JobDetail jobDetail=new JobDetail("job1", "jgroup1", MyJob.class);

　　// 定义调度触发规则，比如每1秒运行一次，共运行8次

　　SimpleTrigger simpleTrigger=new SimpleTrigger("simpleTrigger","triggerGroup");

　　// 马上启动

　　simpleTrigger.setStartTime(new Date());

　　// 间隔时间

　　simpleTrigger.setRepeatInterval(1000);

　　// 运行次数

　　simpleTrigger.setRepeatCount(8);

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(jobDetail, simpleTrigger);

　　// 启动调度

　　scheduler.start();

　　}catch(SchedulerException e){

　　e.printStackTrace();

　　}

　　}

　　} 若使用CornTrigger触发器：

　　[html]

　　package com.test;

　　import java.util.Date;

　　import org.quartz.CronTrigger;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleTrigger;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class CronTriggerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类

　　JobDetail jobDetail=new JobDetail("job1", "jgroup1", MyJob.class);

　　// 定义调度触发规则，每天上午10：15执行

　　CronTrigger cornTrigger=new CronTrigger("cronTrigger","triggerGroup");

　　// 执行规则表达式

　　cornTrigger.setCronExpression("0 15 10 * * ? *");

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(jobDetail, cornTrigger);

　　// 启动调度

　　scheduler.start();

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　}

　　package com.test;

　　import java.util.Date;

　　import org.quartz.CronTrigger;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleTrigger;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class CronTriggerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类

　　JobDetail jobDetail=new JobDetail("job1", "jgroup1", MyJob.class);

　　// 定义调度触发规则，每天上午10：15执行

　　CronTrigger cornTrigger=new CronTrigger("cronTrigger","triggerGroup");

　　// 执行规则表达式

　　cornTrigger.setCronExpression("0 15 10 * * ? *");

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(jobDetail, cornTrigger);

　　// 启动调度

　　scheduler.start();

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　}

　　对于2.0.2jar包如下：

　　其中的job类不变，主要是调度类如下：

　　[html]

　　package com.test;

　　import java.util.Date;

　　import org.quartz.CronScheduleBuilder;

　　import org.quartz.JobBuilder;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleScheduleBuilder;

　　import org.quartz.Trigger;

　　import org.quartz.TriggerBuilder;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class SchedulerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类

　　JobDetail job=JobBuilder.newJob(MyJob.class).withIdentity("job1", "jgroup1").build();

　　// 定义调度触发规则

　　// 使用simpleTrigger规则

　　// Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup")

　　// .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withRepeatCount(8))

　　// .startNow().build();

　　// 使用cornTrigger规则 每天10点42分

　　Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup")

　　.withSchedule(CronScheduleBuilder.cronSchedule("0 42 10 * * ? *"))

　　.startNow().build();

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(job, trigger);

　　// 启动调度

　　scheduler.start();

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　}

　　package com.test;

　　import java.util.Date;

　　import org.quartz.CronScheduleBuilder;

　　import org.quartz.JobBuilder;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.quartz.SchedulerFactory;

　　import org.quartz.SimpleScheduleBuilder;

　　import org.quartz.Trigger;

　　import org.quartz.TriggerBuilder;

　　import org.quartz.impl.StdSchedulerFactory;

　　/**

　　* 调用任务的类

　　* @author lhy

　　*

　　*/

　　public class SchedulerTest {

　　public static void main(String[] args) {

　　//通过schedulerFactory获取一个调度器

　　SchedulerFactory schedulerfactory=new StdSchedulerFactory();

　　Scheduler scheduler=null;

　　try{

　　// 通过schedulerFactory获取一个调度器

　　scheduler=schedulerfactory.getScheduler();

　　// 创建jobDetail实例，绑定Job实现类

　　// 指明job的名称，所在组的名称，以及绑定job类

　　JobDetail job=JobBuilder.newJob(MyJob.class).withIdentity("job1", "jgroup1").build();

　　// 定义调度触发规则

　　// 使用simpleTrigger规则

　　// Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup")

　　// .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withRepeatCount(8))

　　// .startNow().build();

　　// 使用cornTrigger规则 每天10点42分

　　Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup")

　　.withSchedule(CronScheduleBuilder.cronSchedule("0 42 10 * * ? *"))

　　.startNow().build();

　　// 把作业和触发器注册到任务调度中

　　scheduler.scheduleJob(job, trigger);

　　// 启动调度

　　scheduler.start();

　　}catch(Exception e){

　　e.printStackTrace();

　　}

　　}

　　}

　　上述demo下载：1.8版本demo下载

　　2.0版本demo下载

　　对于CornExpress讲解如下：

　　字段 允许值 允许的特殊字符

　　秒 0-59 , - * /

　　分 0-59 , - * /

　　小时 0-23 , - * /

　　日期 1-31 , - * ? / L W C

　　月份 1-12 或者 JAN-DEC , - * /

　　星期 1-7 或者 SUN-SAT , - * ? / L C #

　　年(可选) 留空, 1970-2099 , - * /

　　表达式 意义

　　"0 0 12 * * ?" 每天中午12点触发

　　"0 15 10 ? * *" 每天上午10:15触发

　　"0 15 10 * * ?" 每天上午10:15触发

　　"0 15 10 * * ? *" 每天上午10:15触发

　　"0 15 10 * * ? 2005" 2005年的每天上午10:15触发

　　"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发

　　"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发

　　"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

　　"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发

　　"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发

　　"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发

　　"0 15 10 15 * ?" 每月15日上午10:15触发

　　"0 15 10 L * ?" 每月最后一日的上午10:15触发

　　"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发

　　"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发

　　"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

　　特殊字符 意义

　　* 表示所有值;

　　? 表示未说明的值，即不关心它为何值;

　　- 表示一个指定的范围;

　　, 表示附加一个可能值;

　　/ 符号前表示开始时间，符号后表示每次递增的值;

　　L("last") ("last") "L" 用在day-of-month字段意思是 "这个月最后一天";用在 day-of-week字段, 它简单意思是 "7" or "SAT"。 如果在day-of-week字段里和数字联合使用，它的意思就是 "这个月的最后一个星期几" – 例如： "6L" means "这个月的最后一个星期五". 当我们用“L”时，不指明一个列表值或者范围是很重要的，不然的话，我们会得到一些意想不到的结果。

　　W("weekday") 只能用在day-of-month字段。用来描叙最接近指定天的工作日(周一到周五)。例如：在day-of-month字段用“15W”指“最接近这个月第15天的工作日”，即如果这个月第15天是周六，那么触发器将会在这个月第14天即周五触发;如果这个月第15天是周日，那么触发器将会在这个月第16天即周一触发;如果这个月第15天是周二，那么就在tbw触发器这天触发。注意一点：这个用法只会在当前月计算值，不会越过当前月。“W”字符仅能在day-of-month指明一天，不能是一个范围或列表。也可以用“LW”来指定这个月的最后一个工作日。

　　# 只能用在day-of-week字段。用来指定这个月的第几个周几。例：在day-of-week字段用"6#3"指这个月第3个周五(6指周五，3指第3个)。如果指定的日期不存在，触发器就不会触发。

　　C 指和calendar联系后计算过的值。例：在day-of-month 字段用“5C”指在这个月第5天或之后包括calendar的第一天;在day-of-week字段用“1C”指在这周日或之后包括calendar的第一天

posted @ 2013-09-17 15:15 chen11-1 阅读(2011) | 评论 (0) | 编辑 收藏

序列化在IO中读写对象的使用

　   序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

　　序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
　写对象和读对象的时候一定要使用序列化：

　　import java.io.*;

　　class Product implements Serializable {

　　private static final long serialVersionUID = 1L;

　　private float price;

　　private float tax;

　　public Product(float price) {

　　this.price = price;

　　tax = (float)(price*0.20);

　　}

　　public String toString() {

　　return "price:"+price+",tax:"+tax;

　　}

　　}

　　public class CmdDemo {

　　public static void main(String[] strtb) throws Exception {

　　Product p1 = new Product(100);

　　ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream

　　("d:\product.txt"));

　　os.writeObject(p1);

　　os.close();

　　ObjectInputStream is = new ObjectInputStream(new FileInputStream

　　("d:\product.txt"));

　　Product p2 = (Product) is.readObject();

　　System.out.println(p2.toString());

　　}

　　}

posted @ 2013-09-17 15:12 chen11-1 阅读(261) | 评论 (0) | 编辑 收藏

Java数组使用实用的技巧

  本文分享了关于Java数组最顶级的11大方法，帮助你解决工作流程问题，无论是运用在团队环境或是在私人项目中，你都可以直接拿来用！

0.  声明一个数组（Declare an array）
 
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

1.  在Java中输出一个数组（Print an array in Java）
 
int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
 
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
 
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

2. 从数组中创建数组列表（Create an ArrayList from an array）
 
String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

3. 检查爱淘宝数组中是否包含特定值（Check if an array contains a certain value）
 
String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true
 
4. 连接两个数组（ Concatenate two arrays）
 
int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);
5. 声明一个数组内链（Declare an array inline ）
 
method(new String[]{"a", "b", "c", "d", "e"});
 
6. 将数组元素加入到一个独立的字符串中（Joins the elements of the provided array into a single String）

// containing the provided list of elements
// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c
 
7. 将数组列表转换成一个数组 （Covnert an ArrayList to an array）
 
String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
    System.out.println(s);
 
8. 将数组转换成一个集合（Convert an array to a set）
 
Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]
 
9. 反向数组（Reverse an array）
 
int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]
 
10. 删除数组元素（Remove element of an array）
 
int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);
//create a new array
System.out.println(Arrays.toString(removed));
 
One more – convert int to byte array
 
byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
 
for (byte t : bytes) {
   System.out.format("0x%x ", t);
}

posted @ 2013-09-17 15:08 chen11-1 阅读(255) | 评论 (0) | 编辑 收藏

Java动态代理设计模式

 所谓动态代理类是在运行时生成的class，在生成它时，你必须提供一组interface给它，则动态代理类就宣称它实现了这些interface。当然，动态代理类就充当一个代理，你不要企图它会帮你干实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
　　下面通过实例来说明：
　　Subject.java 抽象借口：声明代理对象和真实对象的共同接口
　　[java]
　　public interface Subject {
　　public void doSomething();
　　}
　　public interface Subject {
　　public void doSomething();
　　}
　　RealSubject.java 真实被tb代理对象
　　[java]
　　public class RealSubject implements Subject {
　　@Override
　　public void doSomething() {
　　System.out.println("RealSubject.doSomething");
　　}
　　}
　　public class RealSubject implements Subject {
　　@Override
　　public void doSomething() {
　　System.out.println("RealSubject.doSomething");
　　}
　　}

　　DynamicProxy.java 代理对象
　　[java]
　　import java.lang.reflect.InvocationHandler;
　　import java.lang.reflect.Method;
　　public class DynamicProxy implements InvocationHandler {
　　private Object object;
　　public DynamicProxy(Object object) {
　　this.object = object;
　　}
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
　　System.out.println("Before Invoke ! method : " + method);
　　//我们可以再代理方法调用前后添加功能
　　Object result = method.invoke(object, args);
　　System.out.println("object : " + object + " result : " + result + " args : " + args);
　　System.out.println("After Invoke !");
　　return result;
　　}
　　}
　　import java.lang.reflect.InvocationHandler;
　　import java.lang.reflect.Method;
　　public class DynamicProxy implements InvocationHandler {
　　private Object object;
　　public DynamicProxy(Object object) {
　　this.object = object;
　　}
　　@Override
　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
　　System.out.println("Before Invoke ! method : " + method);
　　//我们可以再代理方法调用前后添加功能
　　Object result = method.invoke(object, args);
　　System.out.println("object : " + object + " result : " + result + " args : " + args);
　　System.out.println("After Invoke !");
　　return result;
　　}
　　}
　　Client.java 测试
　　[java]
　　import java.lang.reflect.InvocationHandler;
　　import java.lang.reflect.Proxy;
　　public class Client {
　　public static void main(String[] args) throws Exception {
　　//创建目标对象，也就是被代理对象
　　RealSubject realSubject = new RealSubject();
　　//将目标对象交给代理
　　InvocationHandler handler = new DynamicProxy(realSubject);
　　// Class proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()
　　// , new Class[]{Subject.class});
　　// Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})
　　// .newInstance(new Object[]{handler});
　　//返回代理对象，相当于上面两句
　　Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
　　realSubject.getClass().getInterfaces(),
　　handler);
　　//叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会
　　//用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，
　　//method为doSomething()，tb参数为方法要传入的参数，这里没有
　　subject.doSomething();
　　}
　　}
　　import java.lang.reflect.InvocationHandler;
　　import java.lang.reflect.Proxy;
　　public class Client {
　　public static void main(String[] args) throws Exception {
　　//创建目标对象，也就是被代理对象
　　RealSubject realSubject = new RealSubject();
　　//将目标对象交给代理
　　InvocationHandler handler = new DynamicProxy(realSubject);
　　// Class proxyClass = Proxy.getProxyClass(Subject.class.getClassLoader()
　　// , new Class[]{Subject.class});
　　// Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class})
　　// .newInstance(new Object[]{handler});
　　//返回代理对象，相当于上面两句
　　Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
　　realSubject.getClass().getInterfaces(),
　　handler);
　　//叫代理对象去doSomething()，其实在代理对象中的doSomething()中还是会
　　//用handler来调用invoke(proxy, method, args) 参数proxy为调用者subject(this)，
　　//method为doSomething()，参数为方法要传入的参数，这里没有
　　subject.doSomething();
　　}
　　}
　　打印结果：
　　Before Invoke ! method : public abstract void Subject.doSomething()
　　RealSubject.doSomething
　　object : RealSubject@ec6b00 result : null args : null
　　After Invoke !
　　注意：
　　Java动态代理涉及到的两个类：
　　InvocationHandler：该接口中仅定义了一个Object : invoke(Object proxy, Method method, Object[] args);参数proxy指代理类，method表示被代理的方法，args为method中的参数数组，返回值Object为代理实例的方法调用返回的值。这个抽象方法在代理类中动态实现。
　　Proxy：所有动态代理类的父类，提供用于创建动态代理类和实例的静态方法。

posted @ 2013-09-10 17:08 chen11-1 阅读(261) | 评论 (0) | 编辑 收藏

30条有用的 Java 编程规则

　(1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字 母。例如：
　　ThisIsAClassName
　　thisIsMethodOrFieldName
　　若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。
　　Java包(Package)属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu 等，全部都应小写(这也是Java 1.1和Java 1.2的区别之一)。
　　(2) 为了常规用途而创建一个类时，请采取“tb经典形式”，并包含对下述元素的定义：
　　equals()
　　hashCode()
　　toString()
　　clone()(implement Cloneable)
　　implement Serializable
　　(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若 进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。
　　(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用(有些时候，方法必须非常大，但它们仍应只做同样的一件事情)。 (5) 设计一个类时，请设身处地为客户程序员考虑一下(类的使用方法应该是非常明确的)。然后，再设身处地为管理代码的人考虑一下(预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单)。
　　(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：
　　■一个复杂的开关语句：考虑采用“多形”机制
　　■数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现
　　■许多成员变量在特征上有很大的差别：考虑使用几个类 。
　　(7) 让一切东西都尽可能地“私有”——private。可使库的某一部分“公共化”(一个方法、类或者一个字段等等)，就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护。
　　(8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的 对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。
　　(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。
　　(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作(参见第14章14.1.2小节的“用内部 类改进代码”)。
　　(11) 尽可能细致地加上释，并用javadoc注释文档语法生成自己的程序文档。
　　(12) 避免使用“魔术数字”，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。
　　(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常——如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个 对象已正确地创建，从而盲目地继续。
　　(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean(布尔)标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类(如果还没有的话)，从而指出一个编程错误。在采取象这样的方案之前，请确定 finalize()能够在自己的系统中工作(可能需要调用System.runFinalizersonExit(true)，从而确保 这一行为)。
　　(15) 在一个特定的作用域内，若一个对象必须清除(非由tb垃圾收集机制处理)，请采用下述方法：初始化对象;若成功，则立即进入一个含有 finally从句的try块，开始清除工作。
　　(16) 若在初始化过程中需要覆盖(取消)finalize()，请记住调用super.finalize()(若Object属于我们的直接超类，则无此必要)。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。
　　(17) 创建大小固定的对象集合时，请将它们传输至一个数组(若准备从一个方法里返回这个集合，更应如此操作)。这样一来，我们就可享受到数组在编 译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象“造型”到数组里。
　　(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个 interface(接口)。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract(抽象)类。接口主要描述了客户希望做什么事情，而一个类则致力于(或允许)具体的实施细节。
　　(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程 中产生不可预知的结果(参见第7章的详细说明)。
　　(20) 对象不应只是简单地容纳一些数据;它们的行为也应得到良好的定义。
　　(21) 在现成类的基础上创建新类时，请首先选择“新建”或“创作”。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场 合使用了继承，则整个设计会变得没有必要地复杂。
　　(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免 的：应直接使用一个“颜色”字段。

　　(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消 息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。
　　(24) 在Java 1.1 AWT 中使用事件“适配器”时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示——只不过代码的工作就变得不正常了。
　　(25) 用合理的设计方案消除“伪功能”。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条“只生成其中一个 ” 注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。
　　(26) 警惕“分析瘫痪”。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防 止在考察细节的时候陷入“死逻辑”中。
　　(27) 警惕“过早优化”。首先让它运行起来，再考虑变得更快——但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候， 才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。
　　(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价 值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能 将你说服。
　　(29) 如认为自己已进行了良好的分析、设计或者实施，那么请稍微更换一下思维角度。试试邀请一些外来人士——并不一定是专家，但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作，看看是否能找出你一度熟视无睹的问题。采取这种方式，往往能在最适合修改的阶段找出一些关键性的问题，避免产品发行后再解决问题而造成的金钱及精力方面的损失。
　　(30) 良好的设计能带来最大的回报。简言之，对于一个特定的问题，通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法，以后的工作就轻松多了，再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报(甚至无可估量)。而且由于自己倾注了大量心血，最终获得一个出色的设计方案，成功的快感也是令人心动的。坚持抵制草草完工的诱惑——那样做往往得不偿失

posted @ 2013-08-23 16:56 chen11-1 阅读(236) | 评论 (0) | 编辑 收藏

单多线程Java算法相比较

1进程和线程的概念
　　1.1什么是进程
　　一个进程就是在一个运行的程序,它有自己独立的内存空间,一组系统资源,每个进程的内部数据和状态都是独立的,例如在window是同时打开多个记事本,虽然它们所运行的程序代码都是一样的,但是所使用的内存空间是独立的,互不干扰.
　　1.2什么是线程
　　线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序的流控制;但与进程不同的是,同类的多个线程共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈
　　1.3进程与线程的区别
　　1. 进程:每个进程都有独立的代码和数据空间(进程上下文) ,tb进程切换的开销大.
　　2. 线程:轻量的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换的开销小.
　　3. 多进程:在操作系统中,能同时运行多个任务程序.
　　4. 多线程:在同一应用程序中,有多个顺序流同时执行.
　　1.4线程创建的两种方式
　　采用继承Thread类创建线程
　　该方法比较简单,主要是通过继承java.lang.Thread类,并覆盖Thread类的run()方法来完成线成的创建.Thread 类是一个具体的类,即不是抽象类,该类封装了线程的行为.要创建一个线程,程序员必须创建一个从 Thread 类导出的新类.Thread类中有两个最重要的函数run()和start().
　　通过实现Runnable接口创建线程
　　该方法通过生成实现java.lang.Runnable接口的类.该接口只定义了一个方法run(),所以必须在新类中实现它.但是 Runnable 接口并没有任何对线程的支持,我们还必须创建 Thread 类的实例,这一点通过 Thread 类的构造函数
　　public Thread(Runnable target);来实现.
　　2 单线程和多线程性能比较
　　以使用蒙特卡罗概率算法求π为例,进行单线程和多线程时间比较
　　2.1什么是蒙特卡罗概率算法

　　蒙特卡罗法(Monte Carlo method)是以概率和统计的理论、方法为基础的一种计算方法,将所求解的问题同一定的概率模型相联系,用电子计算机实现统计模拟或抽样,以获得问题的近似解,故又称统计模拟法或统计试验法. --百度百科
　　蒙特卡罗求算法求π
　　第一步
　　画正方形和内切圆
　　第二步
　　变换表达式
　　正方形面积As=(2R)^2
　　圆的面积Ac=πR^2
　　Ac/As=(2R)^2/πR^2
　　π=4As/Ac
　　令P=As/Sc,则π=4P
　　第三步
　　重复N次实验求平均值
　　在正方形区域内随机生成一个点A,若A落在圆区域内,M++
　　P=M/N
　　π=4P,N的取值越大,π的值越精确
　　2.2 java代码实现算法
　　N取值为10000万,多线程的数为100,每个线程执行100万次模拟实验
　　线程实现
　　import java.util.concurrent.CountDownLatch;
　　public class ProModel implements Runnable {
　　public int N;//随机实验的总次数
　　public static int M;//随机点落在圆中的次数
　　private int id;
　　private final CountDownLatch doneSignal;
　　OBJ semaphore;
　　public ProModel(int id,CountDownLatch doneSignal,int N,OBJ semaphore2){
　　this.id=id;
　　this.doneSignal=doneSignal;
　　this.N=N;
　　this.semaphore=semaphore2;
　　M=0;
　　}
　　public void run(){
　　int tempM=0;
　　for(int i=0;i
　　if(isInCircle()){
　　tempM++;
　　}
　　}
　　synchronized (semaphore) {
　　add(tempM);
　　}
　　doneSignal.countDown();//使end状态减1
　　}
　　public void add(int tempM){
　　System.out.println(Thread.currentThread().getName());
　　M=M+tempM;
　　System.out.println(M);
　　}
　　//随机产生一个在正方形区域的点,判断它是否在圆中
　　public boolean isInCircle(){
　　double x=Math.random();
　　double y=Math.random();
　　if((x-0.5)*(x-0.5)+(y-0.5)*(y-0.5)<0.25)
　　return true;
　　else
　　return false;
　　}
　　public static int getTotal(){
　　return M;
　　}
　　}
　　多线程Main实现
　　import java.util.concurrent.CountDownLatch;
　　import java.util.concurrent.ExecutorService;
　　import java.util.concurrent.Executors;
　　public class MutliThread {
　　public static void main(String[] args) throws InterruptedException {
　　long begin=System.currentTimeMillis();
　　int threadSize=100;
　　int N=1000000;
　　OBJ semaphore = new OBJ();
　　CountDownLatch doneSignal = new CountDownLatch(threadSize);
　　ProModel[] pros=new ProModel[threadSize];
　　//设置特定的线程池,大小为threadSizde
　　System.out.println(“begins!”);
　　ExecutorService exe = Executors.newFixedThreadPool(threadSize);
　　for(int i=0;i
　　exe.execute(new ProModel(i+1,doneSignal,N,semaphore));
　　try{
　　doneSignal.await(); //等待end状态变为0, }catch (InterruptedException e) {
　　// TODO: handle exception35
　　e.printStackTrace();
　　}finally{
　　System.out.println(“ends!”);
　　System.out.println(4*(float)ProModel.getTotal()/(float)(threadSize*N));
　　}
　　exe.shutdown();
　　long end=System.currentTimeMillis();
　　System.out.println(“used time(ms):”+(end-begin));
　　}
　　}
　　class OBJ{}
　　单线程Main实现
　　import java.util.concurrent.CountDownLatch;
　　import java.util.concurrent.ExecutorService;
　　import java.util.concurrent.Executors;
　　public class SingleThread {
　　public static void main(String[] args) {
　　long begin=System.currentTimeMillis();
　　int threadSize=1;
　　int N=100000000;
　　OBJ semaphore = new OBJ();
　　CountDownLatch doneSignal = new CountDownLatch(threadSize);
　　ProModel[] pros=new ProModel[threadSize];
　　//设置特定的线程池,大小为5
　　System.out.println(“begins!”);
　　ExecutorService exe = Executors.newFixedThreadPool(threadSize);
　　for(int i=0;i
　　exe.execute(new ProModel(i+1,doneSignal,N,semaphore));
　　try{
　　doneSignal.await(); //等待end状态变为0, }catch (InterruptedException e) {
　　// TODO: handle exception35
　　e.printStackTrace();
　　}finally{
　　System.out.println(“ends!”);
　　System.out.println(4*(float)ProModel.getTotal()/(float)(threadSize*N));
　　}
　　exe.shutdown();
　　long end=System.currentTimeMillis();
　　System.out.println(“used time(ms):”+(end-begin));
　　}
　　}

posted @ 2013-08-23 16:54 chen11-1 阅读(255) | 评论 (0) | 编辑 收藏

Arrays.asList方法 学习记录

Arrays工具类提供了一些比较实用的方法，比如sort, binarySearch, fill等。其中还有一个asList方法，此方法能够将一个变长参数或者数组转换成List。
　　但是，这个生成的List，它是固定长度的，如果对其进行add或者remove的操作，会抛出UnsupportedOperationException，为什么会这样呢?
　　带着疑问，查看一下Arrays的源码，可以得到问题的结果。
　　Java代码
　　/**
　　* Returns a fixed-size list backed by the specified array. (Changes to
　　* the returned list "write through" to the array.) This method acts
　　* as bridge between array-based and collection-based APIs, in
　　* combination with Collection.toArray. The returned list is
　　* serializable and implements {@link RandomAccess}.
　　*
　　*
　　This method also provides a convenient way to create a fixed-size
　　* list initialized to contain several elements:
　　*
　　* List stooges = Arrays.asList("Larry", "Moe", "Curly");
　　*
　　*
　　* @param a the array by which the list will be backed.
　　* @return a list view of the specified array.
　　* @see Collection#toArray()
　　*/
　　public static List asList(T... a) {
　　return new ArrayList(a);

　　方法asList返回的是new ArrayList(a)。但是，这个ArrayList并不是java.util.ArrayList，它是一个Arrays类中的重新定义的内部类。
　　具体的实现如下：
　　Java代码
　　/**
　　* @serial include
　　*/
　　private static class ArrayList extends AbstractList
　　implements RandomAccess, java.io.Serializable
　　{
　　private static final long serialVersionUID = -2764017481108945198L;
　　private Object[] a;
　　ArrayList(E[] array) {
　　if (array==null)
　　throw new NullPointerException();
　　a = array;
　　}
　　public int size() {
　　return a.length;
　　}
　　public Object[] toArray() {
　　return (Object[])a.clone();
　　}
　　public E get(int index) {
　　return (E)a[index];
　　}
　　public E set(int index, E element) {
　　Object oldValue = a[index];
　　a[index] = element;
　　return (E)oldValue;
　　}
　　public int indexOf(Object o) {
　　if (o==null) {
　　for (int i=0; i
　　if (a[i]==null)
　　return i;
　　} else {
　　for (int i=0; i
　　if (o.equals(a[i]))
　　return i;
　　}
　　return -1;
　　}
　　public boolean contains(Object o) {
　　return indexOf(o) != -1;
　　}
　　}
　　从这个内部类ArrayList的实现可以看出，它继承了类AbstractList,但是没有重写add和remove方法，没有给出具体的实现。查看一下AbstractList类中对add和remove方法的定义，如果一个list不支持add和remove就会抛出UnsupportedOperationException。
　　Java代码
　　public abstract class AbstractList extends AbstractCollection implements List {
　　/**
　　* Sole constructor. (For invocation by subclass constructors, typically
　　* implicit.)
　　*/
　　protected AbstractList() {
　　}
　　/**
　　* Appends the specified element to the end of this List (optional
　　* operation).
　　*
　　* This implementation calls add(size(), o).
　　*
　　* Note that this implementation throws an
　　* UnsupportedOperationException unless add(int, Object)
　　* is overridden.
　　*
　　* @param o element to be appended to this list.
　　*
　　* @return true (as per the general contract of
　　* Collection.add).
　　*
　　* @throws UnsupportedOperationException if the add method is not
　　* supported by this Set.
　　*
　　* @throws ClassCastException if the class of the specified element
　　* prevents it from being added to this set.
　　*
　　* @throws IllegalArgumentException some aspect of this element prevents
　　* it from being added to this collection.
　　*/
　　public boolean add(E o) {
　　add(size(), o);
　　return true;
　　}
　　/**
　　* Inserts the specified element at the specified position in this list
　　* (optional operation). Shifts the element currently at that position
　　* (if any) and any subsequent elements to the right (adds one to their
　　* indices).
　　*
　　* This implementation always throws an UnsupportedOperationException.
　　*
　　* @param index index at which the specified element is to be inserted.
　　* @param element element to be inserted.
　　*
　　* @throws UnsupportedOperationException if the add method is not
　　* supported by this list.
　　* @throws ClassCastException if the class of the specified element
　　* prevents it from being added to this list.
　　* @throws IllegalArgumentException if some aspect of the specified
　　* element prevents it from being added to this list.
　　* @throws IndexOutOfBoundsException index is out of range (index <
　　* 0 || index > size()).
　　*/
　　public void add(int index, E element) {
　　throw new UnsupportedOperationException();
　　}
　　/**
　　* Removes the element at the specified position in this list (optional
　　* operation). Shifts any subsequent elements to the left (subtracts one
　　* from their indices). Returns the element that was removed from the
　　* list.
　　*
　　* This implementation always throws an
　　* UnsupportedOperationException.
　　*
　　* @param index the index of the element to remove.
　　* @return the element previously at the specified position.
　　*
　　* @throws UnsupportedOperationException if the remove method is
　　* not supported by this list.
　　* @throws IndexOutOfBoundsException if the specified index is out of
　　* range (index < 0 || index >= size()).
　　*/
　　public E remove(int index) {
　　throw new UnsupportedOperationException();
　　}
　　}
　　至此，为什么Arrays.asList产生的List是不可添加或者删除，否则会产生UnsupportedOperationException，就可以得到解释了。
　　如果我们想把一个变长或者数据转变成List， 而且tb期望这个List能够进行add或者remove操作，那该怎么做呢?
　　我们可以写一个类似的方法，里面直接采用java.util.ArrayList即可。
　　比如：
　　Java代码
　　import java.util.ArrayList;
　　import java.util.Collections;
　　import java.util.List;
　　public class MyArrays {
　　public static List asList(T... a) {
　　List list = new ArrayList();
　　Collections.addAll(list, a);
　　return list;
　　}
　　}
　　测试代码如下：
　　Java代码
　　import java.util.ArrayList;
　　import java.util.Arrays;
　　import java.util.List;
　　public class Test {
　　@SuppressWarnings("unchecked")
　　public static void main(String[] args) {
　　List stooges = Arrays.asList("Larry", "Moe", "Curly");
　　print(stooges);
　　List> seasonsList = Arrays.asList(retrieveSeasonsList());
　　print(seasonsList);
　　/*
　　* 自己实现一个asList方法，能够添加和删除。
　　*/
　　List list = MyArrays.asList("Larry", "Moe", "Curly");
　　list.add("Hello");
　　print(list);
　　}
　　private static void print(List list) {
　　System.out.println(list);
　　}
　　private static List retrieveSeasonsList() {
　　List seasonsList = new ArrayList();
　　seasonsList.add("Spring");
　　seasonsList.add("Summer");
　　seasonsList.add("Autumn");
　　seasonsList.add("Winter");
　　return seasonsList;
　　}
　　}
　　输出结果：
　　[Larry, Moe, Curly]
　　[[Spring, Summer, Autumn, Winter]]
　　[Larry, Moe, Curly, Hello]

posted @ 2013-07-15 17:08 chen11-1 阅读(227) | 评论 (0) | 编辑 收藏

Java集合框架中几种集合的分析

        集合可以理解为在内存中存放一组对象的容器，对象是数据的封装，而对象又构成了集合。在java中的集合框架是一种线性的数据结构，但是它分为两种，一种是物理结构，一种是逻辑结构。物理结构是一种连续存储的结构，比如说数组;而逻辑结构可以理解为在内存块中是不连续的，比如说链表，一个链表是分为两中内容的，一个是该链表所存储的数据，还有一个呢，那就是指向下一个链表的指针，通过指针而把表给连起来，称之为链表。数组其实也是可以完成像集合一样的存储的，但是数组存在一定的弊端，数组一旦创建，其大小，类型是固定的，在特定的情况下不能更方便的使用，因此，为了与数组互补，集合也就应运而生了。
　　在java.util包中存在三种最重要的集合，其分别是list，set，map，它们各自有各自的特点，这三种都是接口。其中list：1> list的实现类主要有ArrayList，Linkedlist及其Vector，list中存储的数据是有序的，而且也是可以重复的，也就是说list按照添加的顺序，依次的tb存储在list下标从小到大的位置。做一个简单的代码测试
　　public class Test {
　　public static void main(String[] args) {
　　Test test = new Test();
　　test.testList();
　　public void testList(){//类
　　//创建一个List对象
　　List list = new ArrayList();
　　list.add(1);
　　list.add(1);
　　list.add(2);
　　for(Object a:list){
　　System.out.print(a+" ");
　　}
　　}
　　此段代码的运行结果为：{1 1 2}
　　反应了其有序可重复的特点。
　　2>set同样是一个接口，它常用的实现类有Hashset，Treeset。set集合的存储特点可以说是和list完全相反的，它是一种无序而且不能重复的存储特点。同样的用代码做一个测试 public class Test {
　　public static void main(String[] args) {
　　Test test = new Test();
　　test.testSet();
　　public void testSet(){
　　//创建Set对象
　　Set set = new HashSet();
　　set.add(1);
　　set.add(2);
　　set.add(5);
　　set.add(3);
　　set.add(4);
　　set.add(1);
　　set.add(null);
　　System.out.println(set);
　　Iterator it = set.iterator();
　　while(it.hasNext()){//判断有元素可迭代
　　int i = it.next();
　　System.out.print(i+" ");
　　}
　　}
　　}
　　}

　　此段代码的运行结果是：{1 2 3 4 5}
　　可以说明其无序不可重复的特点。
　　3>最后则是map集合，map的实现类常用的有Hashmap，Hashtable和Treemap。
　　map与以上两者稍微的有点不同，它是一种映射关系，在map中，存储两种数据，tb表达为map，而以上两者都只有一个数据，而且都是通过下标来访问的，map中k是不可以重复的，而v是可以重复的，进行一段代码测试
　　public class Test{
　　public static void main(String[] args){
　　testmap test=new testmap();
　　public void testMap(){
　　Map map = new HashMap();
　　map.put(1, "aaa");
　　map.put(2, "bbb");
　　map.put(3,"ccc");
　　map.put(2, "ddd");
　　System.out.println(map);
　　//获取key集合(Set)
　　Set set = map.keySet();
　　Iterator it = set.iterator();
　　while(it.hasNext()){
　　int key = it.next();
　　//通过key获取对应的value值
　　String value = map.get(key);
　　System.out.println("key="+key+" value="+value);
　　}
　　}
　　}
　　}
　　此段代码的运行结果是：key=1 value=aaa;key=2 value=ddd;key=3 value=ccc。
　　这三种集合各有其所试用的地方，对于像我这种初学者可以让整个代码简化，思路更清晰。
　　二：获得各种数据存储方式长度的方法。
　　数组：定义一个数组Array[];那么获得该数组长度的方法是使用其length方法。
　　字符串： String st = "aaa";
　　st.length();
　　这里的length是字符串的一种属性，而数组的length是一种方法。
　　List：迭代或者直接通过下标输出，list.size()
　　set：迭代while(it.hasNext()){//判断有元素可迭代
　　int i = it.next();
　　System.out.print(i+" ");
　　}
　　map：只能用迭代的方法，
　　//获取key集合(Set)
　　Set set = map.keySet();
　　Iterator it = set.iterator();
　　while(it.hasNext()){
　　int key = it.next();
　　//通过key获取对应的value值
　　String value = map.get(key);
　　System.out.println("key="+key+" value="+value);
　　}
　　map先是通过迭代器先得到key值，因为是一种一一对应的关系，所以用key值就可以得到value值了。

posted @ 2013-07-15 16:52 chen11-1 阅读(241) | 评论 (0) | 编辑 收藏

hibernate操作数据库的执行步骤

先举个hibernate执行SQL的例子：
　　[java] view plaincopy
　　public boolean addUser(UserDO userDO) {
　　boolean b = false;
　　if (userDO != null) {
　　try {
　　getHibernateTemplate().save(userDO);
　　b = true;
　　} catch (Exception e) {
　　b = false;
　　}
　　} else {
　　b = false;
　　}
　　return b;
　　}
一、hibernate操作数据库的执行步骤，其实很简单，可以自己实现一个小的hibernate框架：
　　1、运用java反射机制，获得user对象的类型user.class
　　2、参考对象-关系映射元数据(可能是DO的spring注解，可能是hibernate配置文档)，找到和user类对应的表为user表，并建立对象域跟表属性的对应
　　3、根据以上映射信息，生成SQL语句
　　4、通过JDBC API来执行SQL语句
　　二、hibernate的核心接口：
　　1、Configuration接口：配置hibernate，根启动hibernate，创建sessionfactory对象。hibernate通过configuration实例来获得对象-关系映射文件中的元数据，以及动态的配置hibernate属性，然后创建sessionfactory实例。具体执行过程如下：
　　[java] view plaincopy
　　Configuration config=new Configuration();
　　创建configuration实例，configuration类的构造方法中把applicationContext.xml文档加载到内存，tb读取文档中sessionFactory Bean的配置。然后运用java反射机制，获得userDO对象的类型UserDO。configuration类的addClass方法
　　[java] view plaincopy
　　config.addClass(userDO.class);
　　该方法将hbm.xml文档或者通过hibernate注解形式的“对象-关系映射元数据”读入内存，找到和UserDO类对应的表为USER表，并建立对象域跟表属性的对应。
　　2、sessionfactory接口：初始化hibernate，充当数据存储源的代理，创建session对象。一个sessionfactory实例对应着一个数据存储源。重量级，一个数据库只创建一个sessionfactory实例，它需要一个很大的缓存，用来存放预定义的SQL语句及映射的元数据等。
　　3、session接口：负责保存、更新、删除、加载和查询对象。session对象不是线程安全的，因此应该避免过多个线程共享一个session实例。当session执行sql时候，session会针对上面生成的对象和关系映射，动态组成sql语句。
　　4、transaction：事务管理接口。它对底层的事务接口做了封装。
　　5、query：执行数据库查询。query实例封装了一个HQL语句，HQL语句是面向对象的，它引用类名和类的属性。
　　三、hibernate的使用步骤：
　　1、创建hibernate配置文件
　　2、创建持久化类
　　3、创建对象-关系映射文件
　　4、通过hibernate API编写数据库访问代码

posted @ 2013-06-28 17:01 chen11-1 阅读(1035) | 评论 (0) | 编辑 收藏

Java内存管理优化笔记

1. 垃圾回收
　　JVM运行环境中垃圾对象的定义：
　　一个对象创建后被放置在JVM的堆内存(heap)中，当永远不再引用这个对象时，它将被JVM在堆内存(heap)中回收。被创建的对象不能再生，同时也没法通过程序语句释放它们。
　　不可到达的对象被JVM视为垃圾对象，JVM将给这些对象打上标记，然后清扫回收它们，并将散碎的内存单元收集整合。
　　JVM管理的两种类型的内存：
　　堆内存(heap)，主要存储程序在运行时创建或实例化的对象与变量。
　　栈内存(stack)，主要存储程序代码中声明为静态(static)(或非静态)的方法。
　　堆内存(heap)通常情况下被分为两个区域：新对象(new object)区域与老对象(old object)区域。
　　新对象区域：
　　又可细分为Eden区域、From区域与To区域。
　　Eden区域保存新创建的对象。当该区域中的对象满了后，JVM系统将做可达性测试，主要任务是检测有哪些对象由根集合出发是不可到达的，这些对象就可被JVM回收，且将所有的活动对象从Eden区域拷到To区域，此时有一些对象将发生状态交换，有的对象就从To区域被转移到From区域，此时From区域就有了对象。
　　该过程执行期间，JVM的性能非常低下，会严重影响到正在运行的应用的性能。
　　老对象区域：
　　在老对象区域中的对象仍有一个较长的生命周期。经过一段时间后，被转入tb老对象区域的对象就变成了垃圾对象，此时它们被打上相应的标记，JVM将自动回收它们。
　　建议不要频繁强制系统做垃圾回收，因为JVM会利用有限的系统资源，优先完成垃圾回收工作，致使应用无法快速响应来自用户端的请求，这样会影响系统的整体性能。
　　2. JVM中对象的生命周期
　　对象的整个生命周期大致分为7个阶段：创建(creation)、应用(using)、不可视(invisible)、不可到达(unreachable)、可收集(collected)、终结(finalized)、释放(free)。
　　1) 创建阶段
　　系统通过下面步骤，完成对象的创建：
　　a) 为对象分配存储空间
　　b) 开始构造对象
　　c) 递归调用其超类的构造方法
　　d) 进行对象实例初始化与变量初始化
　　e) 执行构造方法体
　　在创建对象时的几个关键应用规则：
　　避免在循环体中创建对象，即使该对象占用内存空间不大
　　尽量及时使对象符合垃圾回收标准
　　不要采用过深的继承层次
　　访问本地变量优于访问类中的变量

posted @ 2013-06-28 16:59 chen11-1 阅读(227) | 评论 (0) | 编辑 收藏

关于Java序列化的一些高级用法

该说的都在注释中说完了。直接给程序吧。
　　[java] view plaincopyprint?
　　package test.javaPuzzler.p5;
　　import java.io.*;
　　import java.io.ObjectInputStream.GetField;
　　import java.io.ObjectOutputStream.PutField;
　　// 转载请注明来自http://blog.csdn.net/sunxing007
　　// 一个类实现Serializable来表明自己可以被序列化;
　　// 有一点需要特别注意的是：
　　// 如果子类实现了Serializable，而父类没有，则父类不会被序列化;
　　public class SerializableObject implements Serializable {
　　// 生成的序列化版本号会因为编译环境，声明的类名，成员名称和数量的变化而不同;
　　// 也就是说这个版本号一定程度上记录着类的定义性的信息，如果类的定义变化了，最好重新生成版本号;
　　// 如果新的代码使用了旧的版本号，则在反序列化的时候，可以兼容读取旧类的字节码而不会报错;
　　private static final long serialVersionUID = 9038542591452547920L;
　　public String name;
　　public String password;
　　// 如果你不希望某个非静态成员被序列化，可以用transient来修饰它;
　　public transient int age;
　　// 静态成员不会被序列化，因为序列化保存的是实例的状态信息，而静态成员是类的状态信息;
　　public static int version = 1;
　　public SerializableObject(String name, String password) {
　　this.name = name;
　　this.password = password;
　　}

// 每个类可以写一个writeObject方法，这个方法将会负责该类自身的序列化过程;
　　// 比如对于敏感信息如password，可以加密之后再序列化;
　　// 这个过程需要用到PutField，它可以指定哪些域会被序列化，怎么序列化(比如加密);
　　// 如果没有定义这个方法，将会调用ObjectOutputStream 的 defaultWriteObject;
　　// 你可以注释掉readObject方法，然后运行测试用例来测试密码是否被加密;
　　private void writeObject(ObjectOutputStream out) throws IOException {
　　PutField putFields = out.putFields();
　　putFields.put("name", name);
　　// 模拟加密密码
　　putFields.put("password", "thePassword:" + password);
　　out.writeFields();
　　}
　　// 每个类可以写一个readObjectb方法，该方法负责该类自身的反序列化过程;
　　// 比如对序列化时加密后的密码解密;
　　// 这个过程需要用到GetField，他可以具体地读取每个域;或执行解密动作等等;
　　// 如果没有定义这个方法，将会调用ObjectInputStream 的 defaultReadObject;
　　private void readObject(ObjectInputStream in)
　　throws ClassNotFoundException, IOException {
　　GetField readFields = in.readFields();
　　// 读取到成员的值之后，直接赋给该域，即完成该域的反序列化;
　　name = (String) readFields.get("name", "defaultName");
　　// 模拟解密密码
　　String encPassword = (String) readFields.get("password",
　　"thePassword:defaultValue");
　　password = encPassword.split(":")[1];
　　}
　　// 序列化
　　// 主要用到ObjectOutputStream;
　　public void save() throws IOException {
　　FileOutputStream fout = new FileOutputStream("e:obj");
　　ObjectOutputStream oout = new ObjectOutputStream(fout);
　　oout.writeObject(this);
　　oout.close();
　　fout.close();
　　}
　　// 反序列化
　　// 主要用到ObjectInputStream
　　public static SerializableObject load() throws IOException,
　　ClassNotFoundException {
　　FileInputStream fin = new FileInputStream("e:obj");
　　ObjectInputStream oin = new ObjectInputStream(fin);
　　Object o = oin.readObject();
　　return (SerializableObject) o;
　　}
　　@Override
　　public String toString() {
　　return "name: " + name + ", password: " + password;
　　}
　　// tb测试用例
　　public static void main(String[] args) throws IOException,
　　ClassNotFoundException {
　　SerializableObject so = new SerializableObject(
　　"http://blog.csdn.net/sunxing007", "123456");
　　so.save();
　　System.out.println(so);
　　System.out.println(SerializableObject.load());
　　}
　　}

posted @ 2013-06-17 16:50 chen11-1| 编辑 收藏

Oracle绝对值函数

1.绝对值：abs()

   select abs(-2) value from dual;

2.取整函数（大）：ceil（）

   select ceil(-2.001) value from dual;(-2)

3.取整函数（小）：floor（）

   select floor(-2.001) value from dual;(-3)

4.取整函数（截取）：trunc（）

   select trunc(-2.001) value from dual; (-2)

5.四舍五入：round（）

   select round(1.234564) value from dual;(1.2346)

6.取平方：Power（m,n）

   select power(4,2) value from dual;(16)

7.取平方根:SQRT()

   select sqrt(16) value from dual;(4)

8.取随机数:dbms_random(minvalue,maxvalue)

   select sys.dbms.random.value(0,1) value from dual;

9.取符号：Sign()

   select sign(-3) value from dual;(-)

10,取集合的最大值:greatest(value)

   select greatest(-1,3,5,7,9) value from dual;(9)

11.取集合的最小值:least(value)

   select least(-1,3,5,7,9) value from dual;(-1)

12.处理Null值：nvl(空值，代替值)

   select  nvl(null,10) value from dual;(10)

13.求字符序号:ascii()

    select ascii(a) value from dual;

14.求序号字符:chr()

    select chr(97) value from dual;

15.链接：concat()

    select concat("11","22") value from dual;(1122)

16.获取系统时间:sysdate()

    select sysdate value from dual;

17.求日期

    select trunc(sysdate) from dual;

18.求时间

    select  to_char(sysdate,"hh24:mm:ss") from dual;

19.首字母大写：InitCAP()

    select INITCAP(abc def ghi) value from dual;tbw(Abc Def Ghi)

posted @ 2013-06-06 10:16 chen11-1| 编辑 收藏

一些非常实用的 Android 开发资源

Sapan Diwakar在过去几年间一直从事Android开发工作，同时他也积累了一些非常实用的Android应用开发资源，希望对你有所帮助。


1.  Android Annotations

Android Annotations是一个能够加速Android开发的开源框架，它可以帮助开发者处理一些前后台任务、rest服务、应用类、代码片段等，让开发者专注于真正重要的东西。

2.  ActionBarSherlok

ActionBarSherlock是一个扩展的Android支持库，旨在允许开发者通过一个单一的API，在所有的Android版本中都能够非常方便地使用活动栏设计模式。

3.  Spring Android

Java开发者应该比较熟悉，这是一个针对Android开发的Spring框架。我使用最多的是RestTemplate功能，此外，AndroidAnnotations已经支持Spring Rest Template，使得编写REST客户端更加容易。

4.  URLImageViewHelper

如果你想在应用程序中通过URL来加载远程图像，这是最好的选择。URLImageViewHelper提供了辅助tb类，可以很容易地加载远程图像，同时还提供了图像缓存功能。

5.  SubtlePatterns

SubtlePatterns提供了一些高质量的纹理图案资源，图案都非常适合作为应用背景，并且使用也很简单。你可以点击这里来看我如何在应用中使用这些图案。

6.  Sliding Menu（滑动菜单）

顾名思义，SlidingMenu是一个在Android应用中添加滑动菜单效果的库，尽管网上还有一些其他类似的库，但我发现从性能和易于集成方面，SlidingMenu是最好的。

7.  Android ViewPagerIndicator

一个非常棒的库，用于在一个多页面切换视图中指示当前的页面。

8.  Vogella Android教程

vogella团队几乎已经将Android开发中的所有事情做成了教程，对于开发入门非常有帮助。

9.  Android-PullToRefresh

针对Android的下拉刷新库。

10.  谷歌的Android教程

开始Android开发必备的指南、培训资源。

11.  Commonsware Github库

几款Android应用开发库，可以使你的开发工作更加轻松。

你有什么好的资源，欢迎补充。

posted @ 2013-06-04 16:25 chen11-1 阅读(167) | 评论 (0) | 编辑 收藏

java 数据库通用操作类

package com.hospital.dao.tools;
 
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.log4j.Logger;
 
/**
 * 数据库操作管理类
 * 
 * @author Harlyhood
 * 
 */
public class DBManager {
 
    // --------------------------------------------------------- Instance
    private static Logger logger = Logger.getLogger(DBManager.class);
    // --------------------------------------------------------- Methods
 
    // 数据库连接对象
    private Connection con;
    // SQL语句对象
    private Statement stmt;
    // 带参数的Sql语句对象
    private PreparedStatement pstmt;
    // 记录集对象
    private ResultSet rs;
    // 数据连接管理（连接池对象）
    private DBConnectionManager dcm = null;
 
    /** ***********************手动设置的连接参数********************************* */
    @SuppressWarnings("unused")
    private static String _DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    @SuppressWarnings("unused")
    private static String _URL = "jdbc:sqlserver://localhost:1433;database=Hospital_AI_DB;characterEncoding=gb2312";
    @SuppressWarnings("unused")
    private static String _USER_NA = "sa";
    @SuppressWarnings("unused")
    private static String _PASSWORD = "";
 
    /** ********************************************************************** */
 
    // 默认构造
    public DBManager() {
    }
 
    /** ****************************************************************************************** */
    /**
     * **************************************** 数据库连接初始化
     * ***********************************
     */
    /** ****************************************************************************************** */
 
    /**
     * 得到一个默认的数据库连接[从 com.hospital.dao.tools.db.properties文件初始化]
     * 
     * @throws Exception
     */
    private void getConnection() {
        logger.info("###############open:::::从默认的配置文件得到一个数据库连接");
        // 获取一个连接tb池管理类的实例
        dcm = DBConnectionManager.getInstance();
        // 得到一个数据库连接
        con = dcm.getConnection("mysql");
 
        try {
            con.setAutoCommit(false);
        } catch (SQLException e) {
 
            e.printStackTrace();
        }
    }
 
    /**
     * 从指定参数得到一个连接对象
     * 
     * @param driver
     * @param url
     * @param user_na
     * @param password
     * @throws Exception
     */
    public void getConnection(String driver, String url, String user_na,
            String password) throws Exception {
        try {
            logger.info("###############open:::::从指定配置中得到一个数据库连接");
            Class.forName(driver);
            con = DriverManager.getConnection(url, user_na, password);
        } catch (ClassNotFoundException ex) {
            logger
                    .info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]找不到类驱动类: "
                            + driver);
            throw ex;
        } catch (SQLException ex) {
            logger
                    .info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]加载类: "
                            + driver + " 时出现 SQLException 异常");
            throw ex;
        }
    }
 
    /** ****************************************************************************************** */
    /**
     * **************************************** 数据库操作方法
     * ***********************************
     */
    /** ****************************************************************************************** */
 
    /**
     * 执行SQL语句操作(更新数据 无参数)
     * 
     * @param strSql
     *            SQL语句
     * @throws Exception
     */
    public boolean executeUpdate(String strSql) throws SQLException {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        boolean flag = false;
        stmt = con.createStatement();
        logger.info("###############::执行SQL语句操作(更新数据 无参数):" + strSql);
        try {
            if (0 < stmt.executeUpdate(strSql)) {
                close_DB_Object();
                flag = true;
                con.commit();
            }
        } catch (SQLException ex) {
            logger
                    .info("###############Error DBManager Line126::执行SQL语句操作(更新数据 无参数):"
                            + strSql + "失败!");
            flag = false;
            con.rollback();
            throw ex;
        }
        return flag;
 
    }
 
    /**
     * 执行SQL语句操作(更新数据 有参数)
     * 
     * @param strSql
     *            sql指令
     * @param prams
     *            参数列表
     * @return
     * @throws SQLException
     */
    public boolean executeUpdate(String strSql, HashMap<Integer, Object> prams)
            throws SQLException, ClassNotFoundException {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        boolean flag = false;
        try {
            pstmt = con.prepareStatement(strSql);
            setParamet(pstmt, prams);
            logger.info("###############::执行SQL语句操作(更新数据 有参数):" + strSql);
 
            if (0 < pstmt.executeUpdate()) {
                close_DB_Object();
                flag = true;
                con.commit();
            }
        } catch (SQLException ex) {
            logger
                    .info("###############Error DBManager Line121::执行SQL语句操作(更新数据 无参数):"
                            + strSql + "失败!");
            flag = false;
            con.rollback();
            throw ex;
        } catch (ClassNotFoundException ex) {
            logger
                    .info("###############Error DBManager Line152::执行SQL语句操作(更新数据 无参数):"
                            + strSql + "失败! 参数设置类型错误!");
            con.rollback();
            throw ex;
        }
        return flag;
 
    }
 
    /**
     * 执行SQL语句操作(查询数据 无参数)
     * 
     * @param strSql
     *            SQL语句
     * @return 数组对象列表
     * @throws Exception
     */
    public ArrayList<HashMap<Object, Object>> executeSql(String strSql)
            throws Exception {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        stmt = con.createStatement();
        logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
        rs = stmt.executeQuery(strSql);
        con.commit();
        if (null != rs) {
            return convertResultSetToArrayList(rs);
        }
        close_DB_Object();
        return null;
    }
 
    /**
     * 执行SQL语句操作(查询数据 有参数)
     * 
     * @param strSql
     *            SQL语句
     * @param prams
     *            参数列表
     * @return 数组对象列表
     * @throws Exception
     */
    public ArrayList<HashMap<Object, Object>> executeSql(String strSql,
            HashMap<Integer, Object> prams) throws Exception {
        getConnection();
        // getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
        pstmt = con.prepareStatement(strSql);
        setParamet(pstmt, prams);
        logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
        rs = pstmt.executeQuery();
        con.commit();
        if (null != rs) {
            return convertResultSetToArrayList(rs);
        }
        return null;
    }
 
    /**
     * 执行存储过程(查询数据 无参数)
     * 
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
            String procName) throws Exception {
        getConnection();// 获取连接
        String callStr = "{call " + procName + "}";// 构造执行存储过程的sql指令
        CallableStatement cs = con.prepareCall(callStr);
        logger.info("###############::执行存储过程(查询数据):" + procName);
        rs = cs.executeQuery();
        con.commit();
        cs.close();
        close_DB_Object();
        return convertResultSetToArrayList(rs);
    }
 
    /**
     * 执行存储过程(查询数据,带参数)返回结果集合
     * 
     * @param procName
     *            存储过程名称
     * @param parameters
     *            参数对象数组
     * @param al
     *            数组列表对象
     * @return 数组列表对象
     * @throws Exception
     */
    public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
            String procName, Object[] parameters) throws Exception {
        int parameterPoint = 0;
        // 获取存储过程信息列表集合
        ArrayList<HashMap<Object, Object>> procedureInfo = getProcedureInfo(procName);
        // 获取存储过程的完全名称
        String procedureCallName = getProcedureCallName(procName,parameters.length);
        // 获取连接对象
        getConnection();
        // 初始化 存储过程 执行对象
        CallableStatement cs = con.prepareCall(procedureCallName);
        // 参数下标变量
        int index = 0;
        // 获取 存储过程信息列表集合的 迭代器 对象
        Iterator<HashMap<Object, Object>> iter = procedureInfo.iterator();
        // 遍历存储过程信息列表集合
        while (iter.hasNext()) {
            HashMap<Object, Object> hm = iter.next();
 
            parameterPoint++;
            // 如果参数是输入参数 way = 0
            if (hm.get("WAY").equals("0")) {
                // 设置参数到cs
                cs.setObject(parameterPoint, parameters[index]);
                // 参数下标+1
                index++;
            }
        }
        // 释放这个对象,做为第二次使用
        procedureInfo = null;
        logger.info("###############::执行存储过程(查询数据):::::" + procedureCallName);
        rs = cs.executeQuery();
        con.commit();
        procedureInfo = convertResultSetToArrayList(rs);
        cs.close();
        close_DB_Object();
        return procedureInfo;
 
    }
 
    /**
     * 执行存储过程(更新，查询数据[简单查询、非纪录集]，返回输出参数[非纪录集])
     * 
     * @param procName
     *            存储过程名称
     * @param parameters
     *            参数对象数组
     * @param os
     *            输出参数对象数组
     * @return 输出参数对象数组
     * @throws Exception
     */
    public Object[] executeProcedureUpdate(String procName, Object[] parameters)
            throws Exception {
        logger.info("------------------------------------------------------------------------------------------------------");
        logger.info(" Run --> executeProcedureUpdate ##############   正在执行 存储过程: " + procName +"   ##############");
        CallableStatement cs = null;
        Object []returnVal = null;
        try {
        // 获取 存储过程 调用全名
        String fullPCallName = getProcedureCallName(procName,parameters.length);
        logger.info(" Run --> executeProcedureUpdate #   存储过程命令: " + fullPCallName +"   #");
        //获取存储过程参数信息
        ArrayList<HashMap<Object, Object>> p_Call_Info_List = getProcedureInfo(procName);
        //获取连接
        getConnection();
        //创建 存储过程 执行对象
        cs = con.prepareCall(fullPCallName);
        //数组下标
        int index = 1;
        //输出参数下标 纪录
        ArrayList<Integer> outPutIndexList = new ArrayList<Integer>();
        logger.info(" Run --> executeProcedureUpdate #   参数个数是: " + parameters.length +"   #");
        for(HashMap<Object,Object> tempHash:p_Call_Info_List)
        {
            if("0".equals(tempHash.get("WAY")))
            {
                //设置输入参数
                cs.setObject(index, parameters[index-1]);
                logger.info(" Run --> executeProcedureUpdate #   输入 Input: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
            }
            else
            {
                //注册输出参数
                cs.registerOutParameter(index, getDataType(tempHash.get("TYPENAME").toString()));
                //纪录输出参数的下标
                outPutIndexList.add(index);
                logger.info(" Run --> executeProcedureUpdate #   输出 OutPut: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+"   #");
            }
            index++;
        }
        logger.info(" Run --> executeProcedureUpdate #   参数设置完毕,正在执行中  :   #");
         
        //-------------------- 执行 -----------------
        if(!cs.execute())
        {
            returnVal = new Object[outPutIndexList.size()];
            logger.info(" Run --> executeProcedureUpdate #   执行成功! :   #");
            //取输 出参数的 返回值
            for(int i = 0 ;i<outPutIndexList.size();i++)
            {
                returnVal[i] = cs.getObject(outPutIndexList.get(i));
                logger.info(" Run --> executeProcedureUpdate #   返回值 "+(i+1)+" "+returnVal[i]+"   #");
            }
            con.commit();//提交
        }
        } catch (Exception e) {
            logger.info(" Run --> executeProcedureUpdate #   执行失败!事务回滚中 :   #");
            con.rollback();
            throw e;
        } 
        logger.info("------------------------------------------------------------------------------------------------------");
        return returnVal;
    }
 
    /** ****************************************************************************************** */
    /**
     * ********************************* 小工具
     * ************************************************
     */
    /** ****************************************************************************************** */
 
    /**
     * 关闭数据对象
     */
    public void close_DB_Object() {
        logger.info("###############close:::::关闭连接对象，语句对象，记录集对象");
        if (null != rs) {
            try {
                rs.close();
            } catch (SQLException ex) {
                rs = null;
            }
        }
        if (null != stmt) {
            try {
                stmt.close();
            } catch (SQLException ex) {
                stmt = null;
            }
        }
        if (null != pstmt) {
            try {
                pstmt.close();
            } catch (SQLException ex) {
                pstmt = null;
            }
        }
        if (con != null) {
            dcm.freeConnection("mysql", con);
        }
    }
 
 
    /**
     * 设置Sql 指令参数
     * 
     * @param p_stmt
     *            PreparedStatement
     * @param pramets
     *            HashMap
     */
    private PreparedStatement setParamet(PreparedStatement p_stmt,
            HashMap<Integer, Object> pramets) throws ClassNotFoundException,
            SQLException {
        // 如果参数为空
        if (null != pramets) {
            // 如果参数个数为0
            if (0 <= pramets.size()) {
                for (int i = 1; i <= pramets.size(); i++) {
                    try {
                        // 字符类型 String
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.String")) {
                            p_stmt.setString(i, pramets.get(i).toString());
                        }
                        // 日期类型 Date
                        if (pramets.get(i).getClass() == Class
                                .forName("java.sql.Date")) {
                            p_stmt.setDate(i, java.sql.Date.valueOf(pramets
                                    .get(i).toString()));
                        }
                        // 布尔类型 Boolean
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Boolean")) {
                            p_stmt.setBoolean(i, (Boolean) (pramets.get(i)));
                        }
                        // 整型 int
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Integer")) {
                            p_stmt.setInt(i, (Integer) pramets.get(i));
                        }
                        // 浮点 float
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Float")) {
                            p_stmt.setFloat(i, (Float) pramets.get(i));
                        }
                        // 双精度型 double
                        if (pramets.get(i).getClass() == Class
                                .forName("java.lang.Double")) {
                            p_stmt.setDouble(i, (Double) pramets.get(i));
                        }
 
                    } catch (ClassNotFoundException ex) {
                        throw ex;
                    } catch (SQLException ex) {
                        throw ex;
                    }
                }
            }
        }
        return p_stmt;
    }
 
    /**
     * 转换记录集对象为数组列表对象
     * 
     * @param rs
     *            纪录集合对象
     * @return 数组列表对象
     * @throws Exception
     */
    private ArrayList<HashMap<Object, Object>> convertResultSetToArrayList(
            ResultSet rs) throws Exception {
        logger.info("###############::转换记录集对象为数组列表对象");
        // 获取rs 集合信息对象
        ResultSetMetaData rsmd = rs.getMetaData();
        // 创建数组列表集合对象
        ArrayList<HashMap<Object, Object>> tempList = new ArrayList<HashMap<Object, Object>>();
        HashMap<Object, Object> tempHash = null;
        // 填充数组列表集合
        while (rs.next()) {
            // 创建键值对集合对象
            tempHash = new HashMap<Object, Object>();
            for (int i = 0; i < rsmd.getColumnCount(); i++) {
                // 遍历每列数据，以键值形式存在对象tempHash中
                tempHash.put(rsmd.getColumnName(i + 1).toUpperCase(), rs
                        .getString(rsmd.getColumnName(i + 1)));
            }
            // 第一个键值对，存储在tempList列表集合对象中
            tempList.add(tempHash);
        }
        close_DB_Object();// 关闭相关链接
        return tempList;// 返回填充完毕的数组列表集合对象
    }
 
    /**
     * 从数据库得到tb存储过程信息
     * 
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    private ArrayList<HashMap<Object, Object>> getProcedureInfo(String procName)
            throws Exception {
        return this.executeSql("select Syscolumns.isoutparam as Way,systypes.name as TypeName from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
                + procName + "' order by Syscolumns.isoutparam");
    }
 
    /**
     * 从数据库得到存储过程参数个数
     * 
     * @param procName
     *            存储过程名称
     * @return 数组列表对象
     * @throws Exception
     */
    @SuppressWarnings("unused")
    private int getParametersCount(String procName) throws Exception {
        int returnVal = 0;
        for (HashMap<Object, Object> tempHas : this
                .executeSql("select count(*) as RowsCount from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
                        + procName + "'")) {
            returnVal = Integer.parseInt(tempHas.get("ROWSCOUNT").toString());
        }
        return returnVal;
    }
 
    /**
     * 得到调用存储过程的全名
     * 
     * @param procName
     *            存储过程名称
     * @return 调用存储过程的全名
     * @throws Exception
     */
    private String getProcedureCallName(String procName, int prametCount)
            throws Exception {
        String procedureCallName = "{call " + procName;
        for (int i = 0; i < prametCount; i++) {
            if (0 == i) {
                procedureCallName = procedureCallName + "(?";
            }
            if (0 != i) {
                procedureCallName = procedureCallName + ",?";
            }
        }
        procedureCallName = procedureCallName + ")}";
        return procedureCallName;
    }
 
    /**
     * 得到数据类型的整型值
     * 
     * @param typeName
     *            类型名称
     * @return 数据类型的整型值
     */
    private int getDataType(String typeName) {
        if (typeName.equals("varchar"))
            return Types.VARCHAR;
        if (typeName.equals("int"))
            return Types.INTEGER;
        if (typeName.equals("bit"))
            return Types.BIT;
        if (typeName.equals("float"))
            return Types.FLOAT;
        return 0;
    }
 
    // 设置驱动路径
    @SuppressWarnings("static-access")
    public void set_DRIVER(String _DRIVER) {
        this._DRIVER = _DRIVER;
    }
 
    // 设置数据库密码
    @SuppressWarnings("static-access")
    public void set_PASSWORD(String _PASSWORD) {
        this._PASSWORD = _PASSWORD;
    }
 
    // 设置数据库连接字符串
    @SuppressWarnings("static-access")
    public void set_URL(String _URL) {
        this._URL = _URL;
    }
 
    // 设置数据库用户名
    @SuppressWarnings("static-access")
    public void set_USER_NA(String _USER_NA) {
        this._USER_NA = _USER_NA;
    }
 
}

 

posted @ 2013-05-27 16:55 chen11-1 阅读(493) | 评论 (0) | 编辑 收藏

JS计算包含英文与汉字的字符串长度(一个汉字=2个字节)

posted @ 2012-09-17 14:30 chen11-1 阅读(298) | 评论 (0) | 编辑 收藏

JS 获取字符串长度，截取字符串（中英文，一个汉字相当于2个字符）

<script type="text/javascript">
//一个汉字相当于2个字符
    function get_length(s){
        var char_length = 0;
        for (var i = 0; i < s.length; i++){
            var son_char = s.charAt(i);
            encodeURI(son_char).length > 2 ? char_length += 1 : char_length += 0.5;
        }
        return char_length;
    }
    function cut_str(stbr, len){
        var char_length = 0;
        for (var i = 0; i < str.length; i++){
            var son_str = str.charAt(i);
            encodeURI(son_str).length > 2 ? char_length += 1 : char_length += 0.5;
            if (char_length >= len){
                var sub_len = char_length == len ? i+1 : i;
                return str.substr(0, sub_len);
                break;
            }
        }
    }
//  截取15个字（30个字符）
//  cut_str('aa啊啊啊啊啊啊啊啊啊啊啊啊啊k的啊是', 15);
</script>

posted @ 2012-09-17 14:22 chen11-1 阅读(1895) | 评论 (0) | 编辑 收藏

JS截取字符长度（按字节）

1.  
   
2. * 
3.  * 处理过长的字符串，截取并添加省略号 
4.  * 注：半角长度为1，全角长度为2 
5.  *  
6.  * pStr:字符串 
7.  * pLen:截取长度 
8.  *  
9.  * return: 截取后的字符串 
10.  *
    
11. function autoAddEllipsis(pStr, pLen) {  
12.   
13.     var _ret = cutString(pStr, pLen);  
14.     var _cutFlag = _ret.cutflag;  
15.     var _cutStringn = _ret.cutstring;  
16.   
17.     if ("1" == _cutFlag) {  
18.         return _cutStringn + "...";  
19.     } else {  
20.         return _cutStringn;  
21.     }  
22. }  
23.   
24. * 
25.  * 取得指定长度的字符串 
26.  * 注：半角长度为1，全角长度为2 
27.  *  
28.  * pStr:字符串 
29.  * pLen:截取长度 
30.  *  
31.  * return: 截取后的字符串 
32.  *
    
33. function cutString(pStr, pLen) {  
34.   
35.     // 原字符串长度  
36.     var _strLen = pStr.length;  
37.   
38.     var _tmpCode;  
39.   
40.     var _cutString;  
41.   
42.     // 默认情况下，返回的字符串是原字符串的一部分  
43.     var _cutFlag = "1";  
44.   
45.     var _lenCount = 0;  
46.   
47.     var _ret = false;  
48.   
49.     if (_strLen <= pLen/2) {  
50.         _cutString = pStr;  
51.         _ret = true;  
52.     }  
53.   
54.     if (!_ret) {  
55.         for (var i = 0; i < _strLen ; i++ ) {  
56.             if (isFull(pStr.charAt(i))) {  
57.                 _lenCount += 2;  
58.             } else {  
59.                 _lenCount += 1;  
60.             }  
61.   
62.             if (_lenCount > pLen) {  
63.                 _cutString = pStr.substring(0, i);  
64.                 _ret = true;  
65.                 break;  
66.             } else if (_lenCount == pLen) {  
67.                 _cutString = pStr.substring(0, i + 1);  
68.                 _ret = true;  
69.                 break;  
70.             }  
71.         }  
72.     }  
73.       
74.     if (!_ret) {  
75.         _cutString = pStr;  
76.         _ret = true;  
77.     }  
78.   
79.     if (_cutString.length == _strLen) {  
80.         _cutFlag = "0";  
81.     }  
82.   
83.     return {"cutstring":_cutString, "cutflag":_cutFlag};  
84. }  
85.   
86. * 
87.  * 判断是否为全角 
88.  *  
89.  * pChar:长度为1的字符串 
90.  * return: tbtrue:全角 
91.  *          false:半角 
92.  * 
    
93. 
    
94.   
95. function isFull (pChar) { 
    
96.   for (var i = 0; i < pChar.strLen ; i++ ) {     
    
97.     if ((pChar.charCodeAt(i) > 128)) {  
98.         return true;  
99.     } else {  
100.         return false;  
101.     } 
     
102. }
     
103. }
     
104. 用例：
105. testStr = "测试1字符串";
     autoAddEllipsis(testStr, 1); // "测..."
     autoAddEllipsis(testStr, 2); // "测..."
     autoAddEllipsis(testStr, 3); // "测..."
     autoAddEllipsis(testStr, 4); // "测试..."
     autoAddEllipsis(testStr, 5); // "测试1..."
     autoAddEllipsis(testStr, 6); // "测试1..."
     autoAddEllipsis(testStr, 7); // "测试1字..."

posted @ 2012-09-17 14:20 chen11-1 阅读(2642) | 评论 (1) | 编辑 收藏

在线索引重建被取消导致大量ORA-600(kghstack_underflow_internal_3)错误

posted @ 2012-09-13 17:18 chen11-1| 编辑 收藏

安装ORACLE时在Linux上设置内核参数的含义

前两天看到一篇Redhat官方的Oracle安装文档，对于Linux内核参数的修改描述的非常清晰。

 

 

安装Oracle之前，除了检查操作系统的硬件和软件是否满足安装需要之外，一个重点就是修改内核参数，其中最主要的是和内存相关的参数设置。

SHMMAX参数：Linux进程可以分配的单独共享内存段的最大值。一般设置为内存总大小的一半。这个值的设置应该大于SGA_MAX_TARGET或MEMORY_MAX_TARGET的值，因此对于安装Oracle数据库的系统，shmmax的值应该比内存的二分之一大一些。

# grep MemTotal /proc/meminfo
# cat /proc/sys/kernel/shmmax

上面的命令是检查系统内存的大小，以及当前shmmax的设置。

# echo 21474836480 > /proc/sys/kernetbl/shmmax
# sysctl -w kernel.shmmax=21474836480
# echo "kernel.shmmax=21474836480" >> /etc/sysctl.conf

这是设置shmmax参数的几种方法，这三种方式都可以将shmmax设置为20G。这个参数的修改可以不重启数据库。个人推荐使用第二种sysctl命令的方式。采用第三种方式需要执行sysctl –t操作或重启，但是为了确保下次重启后设置值仍然生效，第三种方式是必不可少的。前两种方式类似alter system set scope = memory，而第三种方式则类似alter system set scope = spfile。

SHMMNI参数：设置系统级最大共享内存段数量。Oracle10g推荐最小值为4096，可以适当比4096增加一些。

# cat /proc/sys/kernel/shmmni
# echo 4096 > /proc/sys/kernel/shmmni
# sysctl -w kernel.shmmni=4096
# echo "kernel.shmmni=4096" >> /etc/sysctl.conf

检查和设置方法如上，这和shmmax的修改方式没有区别，不在赘述。

SHMALL参数：设置共享内存总页数。这个值太小有可能导致数据库启动报错。很多人调整系统内核参数的时候只关注SHMMAX参数，而忽略了SHMALL参数的设置。这个值推荐设置为物理内存大小除以分页大小。

# getconf PAGE_SIZE

通过getconf获取分页的大小，用来计算SHMALL的合理设置值：

SQL> select 32*1024*1024*1024/4096 from dual;

32*1024*1024*1024/4096
----------------------
              8388608

对于32G的内存,4K分页大小的系统而言，SHMALL的值应该设置为8388608。

# cat /proc/sys/kernel/shmall
# echo 8388608 > /proc/sys/kernel/shmall
# sysctl -w kernel.shmall=8388608
# echo " kernel.shmall=8388608" >> /etc/sysctl.conf

查询和设置方法如上。

信号灯semaphores是进程或线程间访问共享内存时提供同步的计数器。

SEMMSL参数：设置每个信号灯组中信号灯最大数量，推荐的最小值是250。对于系统中存在大量并发连接的系统，推荐将这个值设置为PROCESSES初始化参数加10。

SEMMNI参数：设置系统中信号灯组的最大数量。Oracle10g和11g的推荐值为142。

SEMMNS参数：设置系统中信号灯的最大数量。操作系统在分配信号灯时不会超过LEAST(SEMMNS,SEMMSL*SEMMNI)。事实上，如果SEMMNS的值超过了SEMMSL*SEMMNI是非法的，因此推荐SEMMNS的值就设置为SEMMSL*SEMMNI。Oracle推荐SEMMNS的设置不小于32000，假如数据库的PROCESSES参数设置为600，则SEMMNS的设置应为：

SQL> select (600+10)*142 from dual;

(600+10)*142
------------
      86620

SEMOPM参数：设置每次系统调用可以同时执行的最大信号灯操作的数量。由于一个信号灯组最多拥有SEMMSL个信号灯，因此有推荐将SEMOPM设置为SEMMSL的值。Oracle验证的10.2和11.1的SEMOPM的配置为100。

通过下面的命令可以检查信号灯相关配置：

# cat /proc/sys/kernel/sem
250 32000 100 128

对应的4个值从左到右分别为SEMMSL、SEMMNS、SEMOPM和SEMMNI。修改方法为：

# echo 610 86620 100 142 > /proc/sys/kernel/sem
# sysctl -w kernel.sem="610 86620 100 142"
# echo "kernel.sem=610 86620 100 142" >> /etc/sysctl.conf

 

posted @ 2012-09-13 17:17 chen11-1| 编辑 收藏

10G开始Oracle区分物化视图和表

posted @ 2012-09-13 17:17 chen11-1| 编辑 收藏

节点重配置后IPC发送超时问题

客户RAC环境在一个节点重启后，另一个节点出现IPC send timeout信息。

 

 

详细错误信息为：

Wed May 2 22:07:00 2012
IPC Send timeout detected.Sender: ospid 20808
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:02 2012
IPC Send timeout detected.Sender: ospid 6677
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:09 2012
IPC Send timeout detected.Sender: ospid 16758
Receiver: inst 1 binc 1718096035 ospid 16261
Wed May 2 22:07:13 2012
IPC Send timeout detected.Sender: ospid 8947
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:13 2012
IPC Send timeout detected.Sender: ospid 6583
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:31 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 132
Wed May 2 22:07:31 2012
IPC Send timeout detected.Sender: ospid 17068
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:34 2012
Communications reconfiguration: tbinstance_number 1
Wed May 2 22:07:34 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 154
Wed May 2 22:07:45 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 64
Wed May 2 22:07:45 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 95
Wed May 2 22:07:54 2012
IPC Send timeout detected.Sender: ospid 21078
Receiver: inst 1 binc 1718095761 ospid 16263
Wed May 2 22:07:59 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 24
Wed May 2 22:08:04 2012
Trace dumping is performing id=[cdmp_20120502220729]
Wed May 2 22:08:24 2012
IPC Send timeout to 0.0 inc 24 for msg type 12 from opid 146
Wed May 2 22:08:36 2012
Trace dumping is performing id=[cdmp_20120502220805]
Wed May 2 22:08:38 2012
Trace dumping is performing id=[cdmp_20120502220805]
Wed May 2 22:10:55 2012
Evicting instance 1 from cluster
Wed May 2 22:11:32 2012
Waiting for instances to leave:
1

这个信息并不正常，查询MOS后发现，这是一个bug，问题描述可以参考：'IPC Send Timeout Detected' errors between QMON Processes after RAC reconfiguration [ID 458912.1]。

对于当前的10.2.0.4环境，需要针对Bug 6200820进行PATCH修正，而对于10.2.0.3版本则需要应用Patch 6326889。

在MOS中查到不少类似IPC Timeout的问题，多数都会影响10.2.0.4版本，且大部分都在10.2.0.5中被fixed，因此如果这个问题出现频繁，升级到10.2.0.5也是一个不错的选择。

posted @ 2012-09-13 17:16 chen11-1| 编辑 收藏

Oracle10g监听listener的总结

#g_kclist{font-size:12px;width:570px;float:none; margin-top:5px; clear:right} #g_kclist a{color:#000; text-decoration:none} #g_kclist h2{margin:0px;padding:0px;font-size:14px; text-align:center;background:url(http://www.thea.cn/zt/zt_img/zczhongduan.gif) no-repeat;line-height:31px;color:#fff} #g_kclist table{line-height:25px;background:#B0DA90;margin-top:8px} #g_kclist table td{ text-align:center;background:#fff} #g_kclist table td.td1 a{color:#f00} #g_kclist table th{background:#F2F7ED;color:#525F46}

posted @ 2012-09-12 14:52 chen11-1| 编辑 收藏

oracle用户登录审计

#g_kclist{font-size:12px;width:570px;float:none; margin-top:5px; clear:right} #g_kclist a{color:#000; text-decoration:none} #g_kclist h2{margin:0px;padding:0px;font-size:14px; text-align:center;background:url(http://www.thea.cn/zt/zt_img/zczhongduan.gif) no-repeat;line-height:31px;color:#fff} #g_kclist table{line-height:25px;background:#B0DA90;margin-top:8px} #g_kclist table td{ text-align:center;background:#fff} #g_kclist table td.td1 a{color:#f00} #g_kclist table th{background:#F2F7ED;color:#525F46}

posted @ 2012-09-12 14:51 chen11-1| 编辑 收藏

异构服务提高Oracle连接异种数据源能力

由于历史的原因，在多数企业都同时存在多个数据库平台，在每个数据库平台上都运行着相关的一套或多套应用。随着单位业务不断扩大，如何在不影响现有应用运行的前提下，快速有效地整合这些分布在单位内部不同数据库平台上的数据，是一个困扰CIO们的问题。面对这一问题，现有解决方案大致可分为以下两种：

　　1．在应用程序上建立连接不同数据源的数据连接，这样做要求程序员分清哪个连接是对应哪个数据库的，而且如果设计时涉及到存储过程还要按照不同数据库的要求分别编写，加重了程序员的要求。

　　2．在数据库中设立快照，定时把其他数据源的数据复制到本地数据库，这样虽然解决了前一种方法中不同数据源的问题，但是由于是定时复制，数据不能实时同步，在实时性要求高的应用中这种方法便不能使用。

　　由于上述两种方法都存在一定的缺点，这里介绍一种Oracle提供的解决oracle数据库与异种数据源的连接问题的解决方案—Oracle的异构服务（Heterogeneous Services）。

　　程序运行效果截图

　　异构服务

　　“异构服务”是集成在Oracle 8i数据库软件中的功能，它提供了从Oracle数据库访问其他非Oracle数据库的通用技术。熟悉Oracle的读者都很清楚，Oracle提供通过建立DB Link的方法访问非本地数据库，而“异构服务”提供通过建立DB Link使你能够执行Oracle SQL查询，透明地访问其他非Oracle数据库里的数据，就像访问Oracle远程数据库一样。“异构服务”分为两种：

　　1． 事务处理服务（Transation Service）：通过事务处理服务，使用户在访问非Oracle数据库中支持事务处理功能。

　　2． SQL服务: 通过SQL服务，使用户直接在Oracle数据库中执行对非Oracle数据库的各种SQL语句。

　　根据异构服务代理程序的不同，“异构服务”连接方式可以分为透明网关和通用连接两种。

　　透明网关（Transparent Gateways） 透明网关使用Oracle提供的特定网关程序来设置代理，tb例如连接SQL Server则必须要有SQL Transparent Gateway for SQL Server。

　　通用连接（Generic Connectivity） 通用连接又分为ODBC连接和OLE DB连接两种，其连接方法和透明网关没有本质区别，只不过通用连接是和数据库一起提供的功能，你不需要向Oracle购买相关的透明网关程序。

　　连接实例

　　这个实例的应用环境是Oracle 8.1.7，操作系统Windows 2000 Server英文版，采用通用连接的ODBC for SQL Server连接SQL Server 2000中文版。安装步骤如下：

　　1． 安装HS部件。

　　缺省情况下，HS服务是和Oracle 8.1.7一起安装的，你可以查询SYS用户下是否存在HS_BASE_CAPS视图，以确认HS部件是否安装，如果没有可以用相关的安装盘进行安装。

　　2． 配置ODBC系统连接字。

　　在控制面板选择“Data Sources (ODBC)”，在“系统DNS”内配置ODBC for SQL Server连接字(dnsora2sql)。

　　3．配置tnsnames.ora，它位于ORACLE_HOME\NETWORK\ADMIN。

　　在这个文件中增加如下代码：

　　Lnk2sql =

　　(DESCRIPTION =

　　(ADDRESS_LIST =

　　(ADDRESS = (PROTOCOL = TCP)(HOST = HOSTNAME)(PORT = 1521)))

　　(CONNECT_DATA =

　　(SID = hs4sql) |< 服务的SID名称，要和Listener里配置的sid相同)

　　(HS=OK) |<　打开HS服务选项

　　)

　　4．配置listener.ora，它位于ORACLE_HOME\NETWORK\ADMIN。

　　在这个文件中增加如下代码：

　　SID_LIST_LISTENER =

　　(SID_LIST =

　　(SID_DESC =

　　(SID_NAME = hs4sql) |<　服务的SID名称，与tnsname名称相对应

　　(ORACLE_HOME = C:\oracle\ora9201)

　　(PROGRAM = hsodbc) |<　要使用的HS服务程序，如果使用OLE DB，程序名为hsole )

　　)

　　5． 重新启动Oracle listener。

　　6． 编辑位于ORACLE_HOME\HS\ADMIN内init.ora，这里是iniths4sql。

　　修改如下两行代码：

　　HS_FDS_CONNECT_INFO = dnsora2sql |<　ODBC系统名

　　HS_FDS_TRACE_LEVEL = 0

　　7． 创建DATABASE LINK。

　　create database link ‘ora2sql’ connect

　　to sql1 identified by sql1 using ‘lnk2sql’;

　　8． 测试连接。如：

　　SQL> select * from 　　到此我们已经完成了使用ODBC连接SQL SERVER的配置工作。

　　总体上说，异构服务扩展了Oracle数据库连接异种数据源的能力，加强了企业数据的整合，是一个快速有效经济地整合企业内部异构数据的解决方案。

posted @ 2012-09-12 14:50 chen11-1| 编辑 收藏

Oracle中利用ADO对象实现存取和访问

　ADO是Active Data Object的缩写，称为ActiveX数据对象。利用ADO对象，通过ODBC驱动程序或OLE DB连接字符串，可实现对任意数据库的存取和访问。

　　OLE DB是微软用来替代ODBC的一种数据库访问技术。是一种对关系型数据库和非关系型数据库均有效的一种数据库访问技术。

　　ADO提供了7个独立的对象，利用这些对象，可实现对数据库的存取和访问：

　　·Connection　连接对象。

　　·Command　命令对象,利用命令对象可执行一个SQL存储过程或有参数的查询。

　　·Parameter　参数对象。

　　·Recordset　记录集对象，代表从数据表中通过查询所获得的一组记录。通过该对象的方法和属性，可实现对记录的存取和操作。

　　·Field　字段对象，代表记录集中的一个字段。Fields为字段集合，tb代表一条记录的全部字段。

　　·Property　属性对象。

　　·Error　错误对象。

　　Connection,Command和Recordset是整个ADO的核心，通过Connection对象与一个数据库建立连接，然后利用Command对象执行查询，从而返回查询结果，并将结果（记录集）存入Recordset对象中，利用服务器端脚本，通过访问Recordset对象，便可获得查询到的记录内容。

　　另外，利用Connection对象的Execute方法和Recordset对象的Open方法，也可执行一个查询，返回一个记录集。

　　ODBC数据源的用户数据源，系统数据源和文件数据源。用户和系统DSN存储在WindowsNT注册表中，系统DSN可被登录的所有用户访问和使用，用户DSN只能提供特定的用户访问和使用。　文件DSN是存储在一个扩展名为.dsn的文本文件中，可供多个用户访问和使用，并可实现复制，通用性强，一般采用此方式。

　　ADO连接对象

　　连接对象在使用前必须先创建该对象的实例：

　　Set 实例名=Server.CreateObject("ADODB.Connection")

　　连接对象的方法：

　　·Open方法

　　连接对象.Open 数据源名 | 连接字符串

　　带参数调用Open方法时，其参数实质是传递给连接对象的ConnectionString属性的。因此，可事先设置ConnectionString属性的值，然后再调用不带参数的Open方法。

　　·Close方法

　　连接对象.Close 释放：Set conn=Nothing

　　·Execute方法

　　该方法用于执行SQL语句。根据SQL语句执行后是否返回记录集，该方法的使用格式分为以下两种：

　　1．执行SQL查询语句时，将返回查询得到的记录集。

　　用法为：

　　Set 对象变量名=连接对象.Execute("SQL 查询语言")

　　Execute方法调用后，会自动创建记录集对象，并将查询结果存储在该记录对象中，通过Set方法，将记录集赋给指定的对象保存，以后对象变量就代表了该记录集对象。

　　2．执行SQL的操作性语言时，没有记录集的返回。

　　此时用法为：

　　连接对象.Execute "SQL 操作性语句" [, RecordAffected][, Option]

　　·RecordAffected 为可选项，此出可放置一个变量，SQL语句执行后，所生效的记录数会自动保存到该变量中。通过访问该变量，就可知道SQL语句队多少条记录进行了操作。

　　·Option 可选项，该参数的取值通常为adCMDText，它用于告诉ADO，应该将Execute方法之后的第一个字符解释为命令文本。通过指定该参数，可使执行更高效。

　　·BeginTrans、RollbackTrans、CommitTrans方法

　　这三个方法是连接对象提供的用于事务处理的方法。BeginTrans用于开始一个事物；RollbackTrans用于回滚事务；CommitTrans用于提交所有的事务处理结果，即确认事务的处理。

　　事务处理可以将一组操作视为一个整体，只有全部语句都成功执行后，事务处理才算成功；若其中有一个语句执行失败，则整个处理就算失败，并恢复到处里前的状态。

　　BeginTrans和CommitTrans用于标记事务的开始和结束，在这两个之间的语句，就是作为事务处理的语句。判断事务处理是否成功，可通过连接对象的Error集合来实现，若Error集合的成员个数不为0，则说明有错误发生，事务处理失败。Error集合中的每一个Error对象，代表一个错误信息。

　　另外，利用SQL本身所提供的事务处理语句，通过编写存储过程，然后利用ADO命令对象的相关方法，通过调用执行存储过程，也可实现事务。

posted @ 2012-09-12 14:49 chen11-1| 编辑 收藏

oracle认证辅导：DECODE()函数用法

DECODE（）函数用法
   
    作用：将输入数值与函数中的参数列表相比较，根据输入值返回一个对应值。函数的参数列表是由若干数值及其对应结果值组成的若干序偶形式。当然，假如未能与任何一个实参序偶匹配成功，则函数也有默认的返回值。 区别于SQL的其它函数，DECODE函数还能识别和操作空值。
   
    语法：DECODE（control_value,value1,result1[,value2,result2…][,default_result]）；
   
    control _value试图处理的数值。DECODE函数将该数值与后面的一系列的偶序相比较，以决定返回值。 value1是一组成序偶的数值。假如输入数值与之匹配成功，则相应的结果将被返回。对应一个空的返回值，可以使用要害字NULL于之对应 result1 是一组成序偶的结果值。 default_result 未能与任何一个值匹配时，函数返回的默认值。
   
    例如： selectdecode（ x , 1 , 'x is 1 ', 2 , 'x is 2 ', 'others'） from dual 当x等于1时，则返回'x is 1'. 当x等于2时，则返回'x is 2'. 否则，返回others'. 需要，比较2个值的时候，可以配合SIGN（）函数一起使用。 SELECT DECODE（ SIGN（5 -6）， 1 'Is Positive', -1, 'Is Nagative', 'Is Zero'） 同样，也可以用CASE实现： SELECT CASE SIGN（5 - 6） WHEN 1 THEN 'Is Positive'WHEN -1 THEN 'Is Nagative'ELSE 'Is Zero' ENDFROM DUAL此外，还可以在Order by中使用Decode. 例如：表table_subject,有subject_name列。要求按照：语、数、外的顺序进行排序。tb这时，就可以非常轻松的使用Decode完成要求了。 select * from table_subject order by decode（subject_name, '语文', 1, '数学', 2, , '外语',3）
   
    将所有的结果全部写出
   
    select * from classes t
   
    数据为
   
    1 1 一班 NUM_1
   
    2 2 二班 NUM_2
   
    3 3 三班 NUM_3
   
    4 4 四班 NUM_4
   
    select t.* from classes t order by decode（t.classnum,'NUM_1',4,'NUM_2',3,'NUM_3',1）；
   
    1 3 三班 NUM_3
   
    2 2 二班 NUM_2
   
    3 1 一班 NUM_1
   
    4 4 四班 NUM_4
   
    必须将所有的结果写出

posted @ 2012-09-11 14:57 chen11-1| 编辑 收藏

Oracle承诺整合Fusion的安全特性

　本周Oracle宣布下一步将全力实施它的安全策略，并透露计划去整合安全产品到应用产品线同时扩展企业安全搜索。为确保自己成为一家名副其实的安全产品厂商，Oracle花费了大量资金，先后收购了许多访问管理、身份管理和其他安全性软件制造商。

　　在周三的安全性策略简报中，Oracle公司承诺将会整合些安全性产品到自己的Fusion应用系统中。该系统将在2008年发布。公司还计划下个月扩展新的企业安全搜索的能力，允许搜索引擎不仅可以搜索Oracle应用系统和数据库而且还可直接访问电子邮件和文件系统。

　　当Oracle做到产品安全时，它的范围将是非常广阔的。在数据库方面，公司提出高级安全性选项用于数据加密，数据库保护用于防止内部用户滥用他们的数据访问权限，安全标签用于指定不同安全级别的数据，安全备份用于加密备份的磁带。Oracle还提供了多样的身份管理能力，包括目录服务、身份验证、web服务访问控制。Oracle还将审计和一致性应用作为其安全措施的一部分。

　　如何辨别安全领域的产品主要看产品是否具备自动安全处理能力如身份管理和数据保护。Oracle负责服务器技术的高级副总裁Thomas Kurian说:“通过Fusion中我们将整合那些全部的安全特性到我们的企业应用中。”但这并意味着Oracle的单机安全应用会在近期发布，目前它还在研发过程中。所以客户需要继续去管理他们的非Oracle的应用系统。

　　Oracle的企业安全搜索可以让企业员工在整个公司数据库和应用系统中搜寻信息。Oracle总裁Charles Phillips说:“客户说希望让他们的用户能够象用Google一样的搜索，但不能搜寻到他们不该看到的信息。”企业安全搜索设计与Oracle Portal开发的企业门户配合使用，如同在Oracle数据库开发数据库应用。公司计划去新增个适配器实现企业对微软Exchange和SharePoint的搜索。

　　企业策略组织的高级分析师Jon Oltsik说，Oracle认定产品的安全特性有广阔市场机会，同样市场目标IBM收购了Internet Security Systems，EMC收购了RSA Security。但是客户关心的是增强他们IT基础设置的安全性，而不是去防止他们咨询奇特的问题。虽然历史不是总能暗示出未来，但IT安全支持者不可能忘记在Oracle危急补丁升级期间的那些坏经历。当Oracle转向安全领域时，它被人们认为是卖万金油的，主要就是他们产品质量的因素。

　　投资者金融服务公司Investors Bank & Trust早已经使用了Oracle的电子商务应用和数据库，但是系统使用的效果没有之前预期的好。该金融服务公司在过去两年一直是采用的IBM的访问和身份管理技术。Investors Bank & Trust公司企业应用主管说:"如果Oracle真的能够将安全特性整合到他们的产品中，能够他们承诺的那样去做的话，他们的软件产品将变的更加引人注目"。

　　从目前来看，Oracle Fusion计划的实现还有很长的路要走。在这期间Oracle需要继续面对那些长期的竞争对手，tb如CA，IBM和sun等。现在的疑问不是Oracle能不能够将安全性产品推销给自己的客户群而是他能不能就产品销售给竞争对手的客户。

#g_kclist{font-size:12px;width:570px;float:none; margin-top:5px; clear:right} #g_kclist a{color:#000; text-decoration:none} #g_kclist h2{margin:0px;padding:0px;font-size:14px; text-align:center;background:url(http://www.thea.cn/zt/zt_img/zczhongduan.gif) no-repeat;line-height:31px;color:#fff} #g_kclist table{line-height:25px;background:#B0DA90;margin-top:8px} #g_kclist table td{ text-align:center;background:#fff} #g_kclist table td.td1 a{color:#f00} #g_kclist table th{background:#F2F7ED;color:#525F46}

posted @ 2012-09-11 14:57 chen11-1| 编辑 收藏

Oracle回滚段空间回收步骤

是谁"偷偷的"用了那么多空间呢(本来有几十个G的Free磁盘空间的)?

　　检查数据库表空间占用空间情况:

　　SQL> select tablespace_name,sum(bytes)/1024/1024/1024 GB

　　2 from dba_data_files group by tablespace_name

　　3 union all

　　4 select tablespace_name,sum(bytes)/1024/1024/1024 GB

　　5 from dba_temp_files group by tablespace_name order by GB;

　　TABLESPACE_NAME                        GB

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

　　USERS                          .004882813

　　UNDOTBS2                        .09765625

　　SYSTEM                         .478515625

　　SYSAUX                         .634765625

　　WAPCM_TS_VISIT_DETAIL            .9765625

　　HY_DS_DEFAULT                           1

　　MINT_TS_DEFAULT                         1

　　MMS_TS_DATA2                        1.375

　　MMS_IDX_SJH                             2

　　MMS_TS_DEFAULT                          2

　　IVRCN_TS_DATA                           2

　　TABLESPACE_NAME                        GB

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

　　MMS_TS_DATA1                            2

　　CM_TS_DEFAULT                           5

　　TEMP                           20.5498047

　　UNDOTBS1                       27.1582031

　　15 rows selected.

　　不幸的发现，UNDO表空间已经扩展至27G，而TEMP表空间也扩展至20G，这2个表空间加起来占用了47G的磁盘空间,导致了空间不足。

　　显然曾经有大事务占用了大量的UNDO表空间和Temp表空间，Oracle的AUM(Auto Undo Management)从出生以来就经常出现只扩展,不收缩(shrink)的情况(通常我们可以设置足够的UNDO表空间大小,然后取消其自动扩展属性).

　　现在我们可以采用如下步骤回收UNDO空间:

　　1.确认文件

　　SQL> select file_name,bytes/1024/1024 from dba_data_files

　　2 where tablespace_name like 'UNDOTBS1';

　　FILE_NAME

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

　　BYTES/1024/1024

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

　　+ORADG/danaly/datafile/undotbs1.265.600173875

　　27810

　　2.检查UNDO Segment状态

　　SQL> select usn,xacts,rssize/1024/1024/1024,hwmsize/1024/1024/1024,shrinks

　　2 from v$rollstat order by rssize;

　　USN      XACTS RSSIZE/1024/1024/1024 HWMSIZE/1024/1024/1024    SHRINKS

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

　　0          0            .000358582             .000358582          0

　　2          0            .071517944             .071517944          0

　　3          0             .13722229              .13722229          0

　　9          0            .236984253             .236984253          0

　　10          0            .625144958             .625144958          0

　　5          1            1.22946167             1.22946167          0

　　8          0            1.27175903             1.27175903          0

　　4          1            1.27895355             1.27895355          0

　　7          0            1.56770325             1.56770325          0

　　1          0            2.02474976             2.02474976          0

　　6          0             2.9671936              2.9671936          0

　　11 rows selected.

　　3.创建新的UNDO表空间

　　SQL> create undo tablespace undotbs2;

　　Tablespace created.

　　4.切换UNDO表空间为新的UNDO表空间

　　SQL> alter system set undo_tablespace=undotbs2 scope=both;

　　System altered.

　　此处使用spfile需要注意，以前曾经记录过这样一个案例:Oracle诊断案例-Spfiletb案例一则

　　5.等待原UNDO表空间所有UNDO SEGMENT OFFLINE

　　SQL> select usn,xacts,status,rssize/1024/1024/1024,hwmsize/1024/1024/1024,shrinks

　　2 from v$rollstat order by rssize;

　　USN      XACTS STATUS          RSSIZE/1024/1024/1024 HWMSIZE/1024/1024/1024    SHRINKS

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

　　14          0 ONLINE                     .000114441             .000114441          0

　　19          0 ONLINE                     .000114441             .000114441          0

　　11          0 ONLINE                     .000114441             .000114441          0

　　12          0 ONLINE                     .000114441             .000114441          0

　　13          0 ONLINE                     .000114441             .000114441          0

　　20          0 ONLINE                     .000114441             .000114441          0

　　15          1 ONLINE                     .000114441             .000114441          0

　　16          0 ONLINE                     .000114441             .000114441          0

　　17          0 ONLINE                     .000114441             .000114441          0

　　18          0 ONLINE                     .000114441             .000114441          0

　　0          0 ONLINE                     .000358582             .000358582          0

　　USN      XACTS STATUS          RSSIZE/1024/1024/1024 HWMSIZE/1024/1024/1024    SHRINKS

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

　　6          0 PENDING OFFLINE             2.9671936              2.9671936          0

　　12 rows selected.

　　再看:

　　11:32:11 SQL> /

　　USN      XACTS STATUS          RSSIZE/1024/1024/1024 HWMSIZE/1024/1024/1024    SHRINKS

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

　　15          1 ONLINE                     .000114441             .000114441          0

　　11          0 ONLINE                     .000114441             .000114441          0

　　12          0 ONLINE                     .000114441             .000114441          0

　　13          0 ONLINE                     .000114441             .000114441          0

　　14          0 ONLINE                     .000114441             .000114441          0

　　20          0 ONLINE                     .000114441             .000114441          0

　　16          0 ONLINE                     .000114441             .000114441          0

　　17          0 ONLINE                     .000114441             .000114441          0

　　18          0 ONLINE                     .000114441             .000114441          0

　　19          0 ONLINE                     .000114441             .000114441          0

　　0          0 ONLINE                     .000358582             .000358582          0

　　11 rows selected.

　　Elapsed: 00:00:00.00

　　6.删除原UNDO表空间

　　11:34:00 SQL> drop tablespace undotbs1 including contents;

　　Tablespace dropped.

　　Elapsed: 00:00:03.13

　　7.检查空间情况

　　由于我使用的ASM管理,可以使用10gR2提供的信工具asmcmd来察看tb空间占用情况.

　　[oracle@danaly ~]$ export ORACLE_SID=+ASM

　　[oracle@danaly ~]$ asmcmd

　　ASMCMD> du

　　Used_MB      Mirror_used_MB

　　21625               21625

　　ASMCMD> exit

　　空间已经释放。

.item-area{width:578px;margin:15px auto;border-top:1px solid #ddd;color:#666} .item-area a,.item-area a:link,.item-area a:visited{color:#666;text-decoration:none} .item-area a:hover{color:#3a7ad9;text-decoration:underline;} a img{border:none;vertical-align:middle} .item-area h2,.item-area h3{float:none;font-size:100%;font-weight:normal;} .item-area .h2{height:25px;margin:10px 0;padding-left:35px;*float:left;font:bold 14px/25px "宋体";background:url(http://sns.thea.cn/module/images/icos.png) no-repeat 0 0} .item-area span.more{float:right;font:normal 12px/25px "宋体"} .item-area a.more{float:right;font:normal 12px/25px "宋体"} .item-a{margin-bottom:15px} .item-a .h-ksrm{background-position:0 0} .item-a li{*display:inline;overflow:hidden;zoom:1;line-height:2em;padding-left:35px;font-size:14px;background: url(http://sns.thea.cn/module/images/btns.png) no-repeat -1px -28px;} .item-a li a{float:left;} .item-a .testBtn{float:right;width:58px;height:21px;line-height:21px;font-size:12px;margin-top:5px;margin-top:3px;text-align:center;background:url(http://sns.thea.cn/module/images/btns.png) no-repeat -1px -1px; color:#FFFFFF;} .item-a a.freeBtn{width:20px;margin:0 0 0 6px;line-height:28px;color:#fff;font-size:12px;text-indent:-9999px;background: url(http://sns.thea.cn/module/images/icos.png) no-repeat 0 -131px;} .item-a li.hots a.freeBtn{background-position:0 -105px} .item-a a.examnum em{font-style:normal;color:red;font-weight:bold;} .item-b {padding:5px 0 20px;border-top:1px dashed #ddd;border-bottom:1px dashed #ddd} .xsjl-list-col3s li{display:table-cell;*display:inline;zoom:1;vertical-align:top;width:182px;padding-right:10px;line-height:150%;font-size:12px;} .item-b .h-xsjl{background-position:0 -26px} .item-b .pic{float:left;margin:3px 10px 0 0;} .item-b em{font-style:normal;color:#dc2c2c} .item-b a.join{display:inline-block;padding-left:20px;background:url(http://sns.thea.cn/module/images/icos.png) no-repeat 0 -160px} .item-b .xsjl-list-col3s h3 a{display:inline-block;width:120px;overflow:hidden;white-space:nowrap;color:#3a7ad9} .item-b .xsjl-list-col3s h3{text-align:left;line-height:150%;font-family:"宋体","微软雅黑"}

posted @ 2012-09-11 14:55 chen11-1| 编辑 收藏

sqlplus直连数据库出现ORA-27504错误

客户数据库使用sqlplus直连方式连接数据库报错，而如果使用tnsnames方式则可以正常连接。

 

 

详细错误信息为：

Thu Apr 26 10:17:56 2012
Errors in file /oracle/admin/trs/udump/trs2_ora_2619.trc:
ORA-00603: ORACLE server session terminated by tb fatal error
ORA-27504: IPC error creating OSD context
ORA-27300: OS system dependent operation:IPC init failed with status: 65
ORA-27301: OS failure message: Package not installed
ORA-27302: failure occurred at: skgxpcini
ORA-27303: additional information: libskgxpd.so called
libskgxp10.so should reference real implementation.

根据MOS文档，这个问题的原因是由于环境变量中指定了CRS的目录，导致部分LIB没有找到：sqlplus Local connection to Instance is not possible , remote Using tns is fine . [ID 859778.1]。

解决问题的方法是在环境变量SHLIB_PATH和LIBPATH中，去掉CRS的HOME信息，使得Oracle正确找到ORACLE_HOME下的LIB目录。

posted @ 2012-09-10 14:31 chen11-1| 编辑 收藏

RAC节点频繁重启出现ORA-29702

posted @ 2012-09-10 14:30 chen11-1| 编辑 收藏

系统空间不足产生ORA-1错误

ORA-1错误代表唯一冲突，而空间不足时出现这个错误还是第一次碰到。

 

 

错误信息如下：

Tue May 01 05:00:11 2012
Non critical error ORA-00001 caught while writing to trace file "/home/oracle/base/diag/rdbms/orcl/orcl/trace/orcl_ora_31131.trc"
Error message: Linux-x86_64 Error: 28: No space left on device
Additional information: 1
Writing to the above trace file is disabled for now on...

这个错误是11.2.0.2引入的，Oracle本应该返回操作系统上的错误，结果返回了ORA-00001错误信息，这是一个未发布的BUG 8367518导致的，可以参考文档Non Critical Error ORA-00001 Caught While Writing To Trace File tb[ID 1354863.1]。

Oracle给出的解决方法就是应用BUG 8367518的补丁，当然这个问题并不严重，完全可以将其忽略。

posted @ 2012-09-10 14:28 chen11-1| 编辑 收藏

GoldenGate导致的Streams miscellaneous event等待事件

posted @ 2012-09-10 14:27 chen11-1 阅读(1209) | 评论 (0) | 编辑 收藏

关于RTX二次开发解决方案

关于RTX二次开发
请问各位高手，怎么能够实现RTX与OA的反向登录啊？由RTX登录OA（有具体代码最好了，RTXClientSDKHandbook.CHM文档 我有）

------解决方案--------------------------------------------------------
自己先顶！！！
------解决方案--------------------------------------------------------
由OA登录RTX很简单，但是反过来，比较难！
------解决方案--------------------------------------------------------
没有搞过rtx啊。原理应该差不多吧，传用户名和密码到OA的登陆页，然后提交就可以了。
------解决方案--------------------------------------------------------
来顶贴！
------解决方案--------------------------------------------------------
就是SSO啊，TB模拟登录

posted @ 2012-09-06 19:58 chen11-1 阅读(323) | 评论 (0) | 编辑 收藏

为啥条码打印出来，扫描枪不能扫描

为什么条码打印出来，扫描枪不能扫描？
条码字体我是从http://font.chinaz.com/TiaoXingMaZiTi.html上下载下来的，字体名字叫做IntHrP72DlTt.TTF，我把字体的fontsize设成了24，但是为什么我打印出来的条码，扫描枪却无法识别呢，扫描枪时二维扫描枪ms1690，测试过无问题

------解决方案--------------------------------------------------------
to use the code providey by the printer provider
------解决方案--------------------------------------------------------
条码打印有没有超出条码纸的边界，如果没有超过，tb把字体调大一下，如果超过把字体调小一些。

posted @ 2012-09-06 19:57 chen11-1| 编辑 收藏

根据这几条反编译后的语句,怎么找到数据库的连接信息

求:根据这几条反编译后的语句,如何找到数据库的连接信息?
我反编译了一个PBD文件,可以看到以下代码片断:
*******************************
  <0><7> create ()
*******************************



appname = "dossier"
message = create message
sqlca = create transaction
sqlda = create dynamicdescriptionarea
sqlsa = create dynamicstagingarea
error = create error

...
uf_window_center(this)
ls_dsn = profilestring("Dagl.ini","tbdatabase","DSN","Error")
..
dagl.ini文件的内容如下:
[system]
AppName="*****"

[database]
DSN=Dagl
LogId=admin

[content]
PaperSize=256
Left=2350
Right=1340
Top=950
Bottom=850

[Post]
PaperSize=256
Left=2500
Right=1940
Top=1530
Bottom=1260

[gz]
PaperSize=256
Left=2000
Right=910
Top=1400
Bottom=1080

我在哪里能找到连接该数据库的连接代码吗?
profilestring

------解决方案--------------------------------------------------------
ODBC吧，看一下ODBC里有没有Dagl。要么注册表里找一下。
------解决方案--------------------------------------------------------
要是看连接该数据库的连接代码就要找 connect using sqlca
要是看数据库连接参数就要通过ODBC，注意ODBC里的用户DSN和系统DSN都要看一下。
顺便问一句用的是什么数据库？

posted @ 2012-09-06 19:56 chen11-1| 编辑 收藏

怎么让multilineedit滚动到最前面

如何让multilineedit滚动到最前面
mle_1.scroll(1)可以实现逐行往下滚动，那请问如何让multilineedit滚动到最前面？


------解决方案--------------------------------------------------------
editname.Scroll(1)就是将multilineedit滚动第一行的，中间的参数是滚到的行数

posted @ 2012-09-06 19:56 chen11-1 阅读(259) | 评论 (0) | 编辑 收藏

单个分区索引失效导致绑定变量查询无法使用索引

一个客户碰到的问题，由于分区维护操作，导致个别分区对应的索引处于UNUSABLE状态，最终导致基于绑定变量的查询无法利用索引。

 

 

通过一个具体的例子来说明这个问题：

SQL> create table t_part
2 (id number,
3 name varchar2(30))
4 partition by range (id)
5 (partition p1 values less than (10),
6 partition p2 values less than (20),
7 partition pmax values less than (maxvalue));

Table created.

SQL> create index ind_t_part_id on t_part(id) local;

Index created.

SQL> insert into t_part
2 select rownum, object_name
3 from user_objects;

94 rows created.

SQL> commit;

Commit complete.

SQL> exec dbms_stats.gather_table_stats(user, 'T_PART', cascade => true)

PL/SQL procedure successfully completed.

SQL> select index_name, partition_name, status
2 from user_ind_partitions
3 where index_name = 'IND_T_PART_ID';

INDEX_NAME PARTITION_NAME STATUS
------------------------------ ------------------------------ --------
IND_T_PART_ID P1 USABLE
IND_T_PART_ID P2 USABLE
IND_T_PART_ID PMAX USABLE

创建分区表后，分别采用硬编码和绑定变量的方式进行查询：

SQL> var v_id number
SQL> exec :v_id := 5

PL/SQL procedure successfully tb completed.

SQL> set autot on exp
SQL> select * from t_part where id = 5;

       ID NAME
---------- ------------------------------
        5 WRH$_ACTIVE_SESSION_HISTORY

Execution Plan
----------------------------------------------------------
Plan hash value: 4087175928

--------------------------------------------------------------------------------------------
|Id|Operation                         |Name        |Rows|Bytes|Cost|Time   |Pstart|Pstop|
--------------------------------------------------------------------------------------------
| 0|SELECT STATEMENT                  |            |  1|  31|  2|00:00:01|     |    |
| 1| PARTITION RANGE SINGLE           |            |  1|  31|  2|00:00:01|   1 |   1|
| 2| TABLE ACCESS BY LOCAL INDEX ROWID|T_PART      |  1|  31|  2|00:00:01|   1 |   1|
|*3|  INDEX RANGE SCAN               |IND_T_PART_ID|  1|    |  1|00:00:01|   1 |   1|
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  3 - access("ID"=5)

SQL> select * from t_part where id = :v_id;

       ID NAME
---------- ------------------------------
        5 WRH$_ACTIVE_SESSION_HISTORY

Execution Plan
----------------------------------------------------------
Plan hash value: 2089936139

--------------------------------------------------------------------------------------------
|Id|Operation                         |Name        |Rows|Bytes|Cost|Time   |Pstart|Pstop|
--------------------------------------------------------------------------------------------
| 0|SELECT STATEMENT                  |            |  1|  17|  2|00:00:01|     |    |
| 1| PARTITION RANGE SINGLE           |            |  1|  17|  2|00:00:01| KEY | KEY|
| 2| TABLE ACCESS BY LOCAL INDEX ROWID|T_PART      |  1|  17|  2|00:00:01| KEY | KEY|
|*3|  INDEX RANGE SCAN               |IND_T_PART_ID|  1|    |  1|00:00:01| KEY | KEY|
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  3 - access("ID"=TO_NUMBER(:V_ID))

无论采用那种方式，Oracle都会选择分区索引扫描的执行计划。

下面MOVE一个查询并不会访问的分区，使其索引状态变为UNUSABLE：

SQL> alter table t_part move partition p2;

Table altered.

SQL> set autot off
SQL> select index_name, partition_name, status
 2 from user_ind_partitions
 3 where index_name = 'IND_T_PART_ID';

INDEX_NAME                    PARTITION_NAME                STATUS
------------------------------ ------------------------------ --------
IND_T_PART_ID                 P1                            USABLE
IND_T_PART_ID                 P2                            UNUSABLE
IND_T_PART_ID                 PMAX                          USABLE

SQL> set autot on exp
SQL> select * from t_part where id = 5;

       ID NAME
---------- ------------------------------
        5 WRH$_ACTIVE_SESSION_HISTORY

Execution Plan
----------------------------------------------------------
Plan hash value: 4087175928

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

|Id|Operation                         |Name        |Rows|Bytes|Cost|Time   |Pstart|Pstop|
--------------------------------------------------------------------------------------------
| 0|SELECT STATEMENT                  |            |  1|  31|  2|00:00:01|     |    |
| 1| PARTITION RANGE SINGLE           |            |  1|  31|  2|00:00:01|   1 |   1|
| 2| TABLE ACCESS BY LOCAL INDEX ROWID|T_PART      |  1|  31|  2|00:00:01|   1 |   1|
|*3|  INDEX RANGE SCAN               |IND_T_PART_ID|  1|    |  1|00:00:01|   1 |   1|
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  3 - access("ID"=5)

SQL> select * from t_part where id = :v_id;

       ID NAME
---------- ------------------------------
        5 WRH$_ACTIVE_SESSION_HISTORY

Execution Plan
----------------------------------------------------------
Plan hash value: 1818654859

--------------------------------------------------------------------------------------------
| Id| Operation             | Name  | Rows | Bytes |Cost(%CPU)| Time    | Pstart| Pstop |
--------------------------------------------------------------------------------------------
| 0| SELECT STATEMENT      |       |   1 |   17 |   2 (0)| 00:00:01 |      |      |
| 1| PARTITION RANGE SINGLE|       |   1 |   17 |   2 (0)| 00:00:01 |  KEY |  KEY |
|* 2|  TABLE ACCESS FULL   | T_PART |   1 |   17 |   2 (0)| 00:00:01 |  KEY |  KEY |
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  2 - filter("ID"=TO_NUMBER(:V_ID))

可以看到，对应非绑定变量方式，Oracle是可以明确定位到要访问的分区，因此SQL执行计划不受影响，仍然是索引扫描。而对于绑定变量的方式则不同，由于这个执行计划对于任何一个输入值都要采用相同的计划，因此Oracle无法判断一个查询是否会访问分区索引UNUSABLE的分区，所以Oracle对于绑定变量的查询采用了单分区的全表扫描执行计划。

为了解决这个问题，除了REBUILD失效的分区外，还可以采用HINT的方式，强制Oracle选择索引扫描的执行计划：

SQL> select /*+ index(t_part ind_t_part_id) */ * from t_part where id = :v_id;

       ID NAME
---------- ------------------------------
        5 WRH$_ACTIVE_SESSION_HISTORY

Execution Plan
----------------------------------------------------------
Plan hash value: 2089936139

--------------------------------------------------------------------------------------------
|Id|Operation                         |Name        |Rows|Bytes|Cost|Time   |Pstart|Pstop|
--------------------------------------------------------------------------------------------
| 0|SELECT STATEMENT                  |            |  1|  17|  2|00:00:01|     |    |
| 1| PARTITION RANGE SINGLE           |            |  1|  17|  2|00:00:01| KEY | KEY|
| 2| TABLE ACCESS BY LOCAL INDEX ROWID|T_PART      |  1|  17|  2|00:00:01| KEY | KEY|
|*3|  INDEX RANGE SCAN               |IND_T_PART_ID|  1|    |  1|00:00:01| KEY | KEY|
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  3 - access("ID"=TO_NUMBER(:V_ID))

SQL> exec :v_id := 15

PL/SQL procedure successfully completed.

SQL> select /*+ index(t_part ind_t_part_id) */ * from t_part where id = :v_id;
select /*+ index(t_part ind_t_part_id) */ * from t_part where id = :v_id
*
ERROR at line 1:
ORA-01502: index 'TEST.IND_T_PART_ID' or partition of such index is in unusable state

SQL> select * from t_part where id = :v_id;

       ID NAME
---------- ------------------------------
       15 WRH$_ACTIVE_SESSION_HISTORY_PK

Execution Plan
----------------------------------------------------------
Plan hash value: 1818654859

--------------------------------------------------------------------------------------------
| Id | Operation             | Name  | Rows | Bytes |Cost(%CPU)| Time    |Pstart| Pstop |
--------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT      |       |   1 |   17 |   2 (0)| 00:00:01 |     |      |
| 1 | PARTITION RANGE SINGLE|       |   1 |   17 |   2 (0)| 00:00:01 | KEY |  KEY |
|* 2 |  TABLE ACCESS FULL   | T_PART |   1 |   17 |   2 (0)| 00:00:01 | KEY |  KEY |
--------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

  2 - filter("ID"=TO_NUMBER(:V_ID))

虽然使用HINT可以让Oracle强制索引扫描，但是如果绑定变量的值指向失效的索引分区，则会导致执行报错。而默认的不使用HINT的语句则不会报错。

posted @ 2012-09-05 11:45 chen11-1| 编辑 收藏

设置全局死锁优先级

测试控制全局死锁的隐含参数_lm_dd_interval时，突然想到这个问题。

RAC全局死锁检测时间：http://yangtingkun.net/?p=955

 

 

Oracle的死锁判断是没有优先级的，也就是说，当两个或多个会话发生死锁的时候，无法指定牺牲哪个会话，而是由Oracle随机决定。

不过对于RAC环境而言，死锁的检查不在是内部的随机实现，Oracle通过隐含参数_lm_dd_interval来控制死锁的检测时间。更重要的是，对于RAC环境而言，Oracle允许不同实例设置不同的值。而不同实例的检测死锁间隔不同，就意味着优先级的出现。

如果实例1上设置该值为默认值60秒，而实例2设置为30秒，那么当发生死锁后，永远是实例2上先检测到死锁，也就是说，实例2上会话会被牺牲掉。

这是两个实例上设置该参数相同的情况，两个会话分别连接到两个实例，产生死锁。实例1上的会话1：

SQL> select name from v$database;

NAME
---------
ORCL

SQL> select instance_number, instance_name from v$instance;

INSTANCE_NUMBER INSTANCE_NAME
--------------- ----------------
              1 orcl1

SQL> set sqlp 'I1S1> '
I1S1> show parameter _lm

NAME                                 TYPE                                 VALUE
------------------------------------ ----------- ------------------------------
_lm_dd_interval                      integer                                 30
I1S1> set timing on
I1S1> update t_deadlock set name = 'a1' where id = 1;

1 row updated.

Elapsed: 00:00:00.07

在实例2上连接会话2：

SQL> select name from v$database;

NAME
---------
ORCL

SQL> select instance_number, instance_name from v$instance;

INSTANCE_NUMBER INSTANCE_NAME
--------------- ----------------
              2 orcl2

SQL> set sqlp 'I2S2> '
I2S2> show parameter _lm

NAME                                 TYPE                                 VALUE
------------------------------------ ----------- ------------------------------
_lm_dd_interval                      integer                                 30
I2S2> set timing on
I2S2> update t_deadlock set name = 'b2' where id = 2;

1 row updated.

Elapsed: 00:00:00.04
I2S2> update t_deadlock set name = 'a2' where id = 1;

会话1上锁定记录2，产生死锁：

I1S1> update t_deadlock set name = 'b1' where id = 2;

第一次是实例2上的会话2被牺牲报错：

update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:00:32.15
I2S2> update t_deadlock set name = 'a2'  where id = 1;

可以看到，会话2等待30秒后报错，此时会话2执行同样的语句再次引发死锁：

update t_deadlock set name = 'b1' where id = 2
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:01:00.39
I1S1> update t_deadlock set name = 'b1' where id = 2;

这次变成实例1上的会话1被牺牲报错，可以看到tb，会话1经历了两次死锁检测，因此执行时间为1分钟。会话1再次引入死锁：

update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:01:01.69
I2S2>

被牺牲的又变成了会话2。

上面这个测试是在两个实例的_lm_dd_interval参数设置相同的情况下，下面修改实例2上的参数设置为5秒：

I2S2> alter system set "_lm_dd_interval" = 5 scope = spfile sid = 'orcl2';

System altered.

Elapsed: 00:00:00.09
I2S2> shutdown immediate
Database closed.
Database dismounted.
ORACLE instance shut down.
I2S2> startup
ORACLE instance started.

Total System Global Area 281018368 bytes
Fixed Size 2095672 bytes
Variable Size 121636296 bytes
Database Buffers 150994944 bytes
Redo Buffers 6291456 bytes
Database mounted.
Database opened.
I2S2> show parameter _lm

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
_lm_dd_interval                      integer     5
I2S2> update t_deadlock set name = 'b2' where id = 2;

1 row updated.

Elapsed: 00:00:00.06

实例2参数生效后连接会话更新该表，实例1上的会话1取消之前的修改，重新进行更新：

1 row updated.

Elapsed: 00:10:08.98
I1S1> rollback;

Rollback complete.

Elapsed: 00:00:00.00
I1S1> update t_deadlock set name = 'a1' where id = 1;

1 row updated.

Elapsed: 00:00:00.01
I1S1> update t_deadlock set name = 'b1' where id = 2;

下面在实例2上的会话2，引入死锁：

I2S2> update t_deadlock set name = 'a2' where id = 1;
update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:00:06.07
I2S2> update t_deadlock set name = 'a2' where id = 1;
update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:00:05.95
I2S2> update t_deadlock set name = 'a2' where id = 1;
update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:00:06.63
I2S2> update t_deadlock set name = 'a2' where id = 1;
update t_deadlock set name = 'a2' where id = 1
*
ERROR at line 1:
ORA-00060: deadlock detected while waiting for resource

Elapsed: 00:00:05.89

显然由于不同实例的_lm_dd_interval参数的值设置不同，现在每次死锁都会在设置值更小的实例2上被检测，实例2上的会话每次都会被死锁牺牲掉。尝试设置不同的参数值在不同实例上设置死锁检测优先级获得成功。

posted @ 2012-09-05 11:45 chen11-1| 编辑 收藏

对象相关开发手册总结

posted @ 2012-09-05 11:43 chen11-1| 编辑 收藏

HASH分区新增分区对索引状态的影响

一直认为Oracle对于所有分区的操作都是一样的，只有数据的改变才会导致分区状态的失效，没想到HASH分区的实现方式并不相同。

HASH分区表增加新的分区的一点研究： 

 

看一个范围分区SPLIT的例子：

SQL> CREATE TABLE T_PART
 2 (ID NUMBER, NAME VARCHAR2(30))
 3 PARTITION BY RANGE (ID)
 4 (PARTITION P1 VALUES LESS THAN (10),
 5 PARTITION PMAX VALUES LESS THAN (MAXVALUE));

Table created.

SQL> INSERT INTO T_PART
 2 SELECT ROWNUM, TNAME 
 3 FROM TAB;

12 rows created.

SQL> CREATE INDEX IND_T_PART_ID ON T_PART(ID) LOCAL;

Index created.tb

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_PART_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_PART_ID                  P1                             USABLE
IND_T_PART_ID                  PMAX                           USABLE

SQL> SELECT COUNT(*) FROM T_PART PARTITION (PMAX);

 COUNT(*)
----------
         3

SQL> ALTER TABLE T_PART SPLIT PARTITION PMAX AT (20)
 2 INTO (PARTITION P2, PARTITION P3);

Table altered.

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_PART_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_PART_ID                  P2                             USABLE
IND_T_PART_ID                  P3                             USABLE
IND_T_PART_ID                  P1                             USABLE

可以看到，对于范围分区而言，即使是SPLIT包含数据的分区，只要没有真正导致数据发生变化，就不会导致索引的失效。这里将PMAX分区SPLIT成P2和P3两个分区，其中PMAX中的所有数据都进入P2分区，而P3分区为空，这种情况下没有数据的改变，因此所有分区索引的状态都不会变为UNUSABLE。

但是HASH分区的ADD PARTITION并没有遵守这个规则，事实上对于每次ADD分区，都会导致一个分区的数据发生分裂，而分裂的结果不管原分区的数据是否发生变化，都会导致原分区索引状态变为UNUSABLE，至于新增分区的索引状态，则取决于是否有数据的改变。

SQL> CREATE TABLE T_HASH
 2 (ID NUMBER)
 3 PARTITION BY HASH (ID)
 4 (PARTITION P1,
 5 PARTITION P2,
 6 PARTITION P3,
 7 PARTITION P4);

Table created.

SQL> CREATE INDEX IND_T_HASH_ID ON T_HASH(ID) LOCAL;

Index created.

SQL> INSERT INTO T_HASH SELECT ROWNUM FROM TAB;

12 rows created.

SQL> COMMIT;

Commit complete.

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_HASH_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_HASH_ID                  P1                             USABLE
IND_T_HASH_ID                  P2                             USABLE
IND_T_HASH_ID                  P3                             USABLE
IND_T_HASH_ID                  P4                             USABLE

SQL> SELECT * FROM T_HASH PARTITION (P1);

        ID
----------
         6
        11

SQL> SELECT * FROM T_HASH PARTITION (P2);

        ID
----------
         9
        10
        12

SQL> SELECT * FROM T_HASH PARTITION (P3);

        ID
----------
         2
         5
         8

SQL> SELECT * FROM T_HASH PARTITION (P4);

        ID
----------
         1
         3
         4
         7

下面新增一个PARTITION P5：

SQL> ALTER TABLE T_HASH ADD PARTITION P5;

Table altered.

SQL> SELECT * FROM T_HASH PARTITION (P5);

no rows selected

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_HASH_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_HASH_ID                  P5                             USABLE
IND_T_HASH_ID                  P1                             UNUSABLE
IND_T_HASH_ID                  P2                             USABLE
IND_T_HASH_ID                  P3                            USABLE
IND_T_HASH_ID                  P4                             USABLE

新增的PARTITION P5中并没有任何的数据，也就是说没有任何的数据从P1迁移到P5中，但是查询分区索引的状态发现，P1对应的分区索引状态已经变为UNUSABLE。这和范围分区的处理方式完全不同。而P5分区由于没有任何数据，因此分区状态是USABLE。

SQL> ALTER TABLE T_HASH ADD PARTITION P6;

Table altered.

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_HASH_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_HASH_ID                  P5                             USABLE
IND_T_HASH_ID                  P6                             UNUSABLE
IND_T_HASH_ID                  P1                             UNUSABLE
IND_T_HASH_ID                  P2                             UNUSABLE
IND_T_HASH_ID                  P3                             USABLE
IND_T_HASH_ID                  P4                             USABLE

6 rows selected.

SQL> DELETE T_HASH WHERE ID = 5;        

1 row deleted.

SQL> COMMIT;

Commit complete.

SQL> ALTER TABLE T_HASH ADD PARTITION P7;

Table altered.

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_HASH_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_HASH_ID                  P5                             USABLE
IND_T_HASH_ID                  P6                             UNUSABLE
IND_T_HASH_ID                  P7                             UNUSABLE
IND_T_HASH_ID                  P1                             UNUSABLE
IND_T_HASH_ID                  P2                             UNUSABLE
IND_T_HASH_ID                  P3                             UNUSABLE
IND_T_HASH_ID                  P4                             USABLE

7 rows selected.

SQL> SELECT * FROM T_HASH PARTITION (P3);

no rows selected

SQL> SELECT * FROM T_HASH PARTITION (P7);

        ID
----------
         2
         8

为了更好的说明这个问题，在增加PARTITION P7之前，删除了ID为5的记录，这是增加分区后可以发现，原有的P3已经不包含任何的数据，全部的记录都进入到新增的P7分区，但是无论是P3还是P7，状态都是UNUSABLE。这证明了前面提到的，只要是新增HASH分区，就会导致源分区索引状态变为UNUSABLE，除非是一种情况：源分区本身就没有数据：

SQL> ALTER TABLE T_HASH ADD PARTITION P8;

Table altered.

SQL> SELECT INDEX_NAME, PARTITION_NAME, STATUS                         
 2 FROM USER_IND_PARTITIONS
 3 WHERE INDEX_NAME = 'IND_T_HASH_ID';

INDEX_NAME                     PARTITION_NAME                 STATUS
------------------------------ ------------------------------ --------
IND_T_HASH_ID                  P5                             USABLE
IND_T_HASH_ID                  P6                             UNUSABLE
IND_T_HASH_ID                  P7                             UNUSABLE
IND_T_HASH_ID                  P1                             UNUSABLE
IND_T_HASH_ID                  P2                             UNUSABLE
IND_T_HASH_ID                  P3                             UNUSABLE
IND_T_HASH_ID                  P4                             USABLE
IND_T_HASH_ID                  P8                             USABLE

8 rows selected.

事实上，对于HASH分区的ADD PARTITION操作，Oracle基本上还是秉承了没有数据变化就不会导致索引失效的思路。唯一的差别在于，对于源分区包含记录的情况，Oracle并没有最后去验证，是否真的发生了数据的迁移。

posted @ 2012-09-05 11:43 chen11-1| 编辑 收藏

参加ACOUG活动

今天是ACOUG活动的日子，也是上半年的最后一天。

 

 

参加ACOUG的人很多，现场估计超过了100人，而且今天到会的ACE也很多，除了tbEygle、Kamus、崔华和刚晋升为ACE的侯圣文之外，还有从成都赶过来的老熊。老熊虽然是第一次见面，此前打交道的次数也不多，但是有种一见如故的感觉，可能和老熊直爽的性格有关。

今天的第一个主题是杨海朝带来的《MySql的那点事儿》。杨海朝是新浪的首席DBA负责新浪微博的后台数据库，他带来的MySql方面的演讲介绍了如何利用mysql处理海量增长的大数据，以及如何满足前端应用的高可用需求。

第二个是Kamus带来的11g新特性。在10g已经推出了正常服务期，12c马上就要推出的今天，仍然有很多DBA对于11g的新特性不是很了解。Kamus的演讲应该算是一个新特性的普及，这次的内容是关于分区和高可用特性方面的新特性。

最后是崔华带来的SQL优化方面的主题，这次的内容是统计信息。崔华的演讲贯彻了他一向的风格，包含了大量的深入信息，并给出了很多Oracle内部算法和公式，而这些公式大部分来自他深入的研究，在其他的地方是无法看到的。

posted @ 2012-09-05 11:41 chen11-1 阅读(317) | 评论 (0) | 编辑 收藏

RAC全局死锁检测时间

posted @ 2012-09-04 17:08 chen11-1| 编辑 收藏

11g数据泵NETWORK_LINK功能增强

posted @ 2012-09-04 16:55 chen11-1 阅读(1328) | 评论 (0) | 编辑 收藏

Oracle高可用最佳实践

如果需要了解或架构高可用环境，建议看一下这篇文档。

 

 

这篇文档介绍了Oracle高可用相关的知识点，包括ASM、CLUSTER、RAC、DATA GUARD、GOLDENGATE、BACKUP、RESTORE等等，此外还介绍了高可用环境的监控，以及如何利用这些高可用功能来减少维护的停机时间。

从文档的名称高可用最佳实践和文档的页数高，这篇文档中不会包括这些知识点的具体概念，而应该是这些功能在哪些场合使用最合适，以及相互之间如何配合。

照例给出网址：http://www.oracle.com/pls/db112/to_toc?pathname=server.112%2Fe10803%2Ftoc.htm&remark=portal+%28Books%29

 

posted @ 2012-09-04 16:54 chen11-1 阅读(203) | 评论 (0) | 编辑 收藏

启动取消导致ORA-600(2658)错误

客户数据库在SHUTDOWN的过程中执行了取消操作，导致了ORA-600错误。

 

 

数据库版本为10.2.0.4 RAC for HP-UX，详细错误信息为：

Thu Oct 22 15:05:14 2009
Shutting down instance: further logons disabled
Thu Oct 22 15:05:15 2009
Stopping background process QMNC
Thu Oct 22 15:05:15 2009
Stopping background process CJQ0
Thu Oct 22 15:05:17 2009
Stopping background process MMNL
Thu Oct 22 15:05:18 2009
Stopping background process MMON
Thu Oct 22 15:05:19 2009
Shutting down instance (immediate)
License high water mark = 8
Thu Oct 22 15:05:19 2009
Stopping Job queue slave processes, flags = 7
Thu Oct 22 15:05:19 2009
Job queue slave processes stopped
Thu Oct 22 15:05:20 2009
ALTER DATABASE CLOSE NORMAL
Thu Oct 22 15:05:20 2009
SMON: disabling tx recovery
SMON: disabling cache recovery tb
Thu Oct 22 15:05:21 2009
LGWR: Waiting for ORLs to be archived...
Thu Oct 22 15:05:36 2009
Reconfiguration started (old inc 2, new inc 4)
List of nodes:
0 1
Global Resource Directory frozen
Communication channels reestablished
* domain 0 valid = 1 according to instance 0
Thu Oct 22 15:05:36 2009
Master broadcasted resource hash value bitmaps
Non-local Process blocks cleaned out
Thu Oct 22 15:05:36 2009
LMS 0: 0 GCS shadows cancelled, 0 closed
Thu Oct 22 15:05:36 2009
LMS 1: 0 GCS shadows cancelled, 0 closed
Set master node info
Submitted all remote-enqueue requests
Dwn-cvts replayed, VALBLKs dubious
All grantable enqueues granted
Thu Oct 22 15:05:36 2009
LMS 1: 2008 GCS shadows traversed, 1001 replayed
Thu Oct 22 15:05:36 2009
LMS 0: 1988 GCS shadows traversed, 1034 replayed
Thu Oct 22 15:05:36 2009
Submitted all GCS remote-cache requests
Fix write in gcs resources
Reconfiguration complete
Thu Oct 22 15:05:51 2009
CLOSE: Error 1013 during database close
Thu Oct 22 15:05:51 2009
SMON: enabling cache recovery
SMON: enabling tx recovery
Thu Oct 22 15:05:51 2009
ORA-1013 signalled during: ALTER DATABASE CLOSE NORMAL...
Thu Oct 22 15:05:51 2009
Errors in file /u01/app/oracle/admin/orcl3/bdump/orcl32_lns1_4678.trc:
ORA-00600: internal error code, arguments: [2658], [4], [2], [], [], [], [], []
Thu Oct 22 15:05:52 2009
Trace dumping is performing id=[cdmp_20091022150552]
Thu Oct 22 15:05:52 2009
Errors in file /u01/app/oracle/admin/orcl3/bdump/orcl32_lns1_4678.trc:
ORA-00600: internal error code, arguments: [2658], [4], [2], [], [], [], [], []
Thu Oct 22 15:05:55 2009
LGWR: ORLs successfully archived
Shutting down archive processes
Archiving is disabled
Thu Oct 22 15:06:00 2009
ARCH shutting down
ARC3: Archival stopped
Thu Oct 22 15:06:05 2009
ARCH shutting down
ARC2: Archival stopped
Thu Oct 22 15:06:10 2009
ARCH shutting down
ARC1: Archival stopped
Thu Oct 22 15:06:15 2009
ARCH shutting down
ARC0: Archival stopped
Thu Oct 22 15:06:16 2009
Thread 2 closed at log sequence 23
Successful close of redo thread 2

可以看到，用户在执行了SHUTDOWN IMMEDIATE操作后，执行了CTRL+C取消操作，导致了ORA-1031错误，之后同一时间引发了ORA-600[2658]错误。显然这个错误的产生和用户发出的取消命令直接相关，而且最终这个命令并未生效，数据库成功的被关闭。

在MOS上查询了一下ORA-600[2658]的相关错误，发现多部分错误都出现在7.3和8.1版本上，在9i以后这个错误已经很少见了，从这一点也可以看出，导致这个错误出现的是偶然的因素，那么取消操作显然是导致这个错误的最大可能性。

数据库本身处于关闭过程中，因此这个错误没有影响，可以直接忽略掉。

posted @ 2012-09-04 16:54 chen11-1 阅读(879) | 评论 (0) | 编辑 收藏

将TIMESTAMP类型的差值转化为秒的方法

posted @ 2012-09-04 16:52 chen11-1| 编辑 收藏

参考手册总结

一直认为这篇文档作为工具书更合适，不过细读的过程中却改变了我的看法。

 

 

之所以这篇文档的优先级放得比较低，和这篇文档的厚度也有关系。不过这1200多页的内容却包含了很多Oracle中最关键的信息。

第一部分就是初始化参数的详细描述，即使这篇文档只包含了这部分内容，也值得一看了。

第二部分是静态数据字典视图，第三部分是动态数据字典视图。这两部分的内容除了作为工具书备查之外，也是补充自己知识全面性的重要文档，Oracle的提供的数据字典覆盖了非常全面的信息，而我们平时只利用了很少的一部分，如果能充分利用这些视图，那么解决问题会更加的轻松。

最后在附录部分还有重要的内容，tb比如所有等待事件的描述。

posted @ 2012-09-03 17:13 chen11-1 阅读(967) | 评论 (0) | 编辑 收藏

discover_server报错OVMAPI_4010E

posted @ 2012-09-03 17:12 chen11-1| 编辑 收藏

Oracle VM Server安装手册

简单描述一下Oracle VM Server的安装过程。

 

 

需要注意，VM 3.0以上版本才支持升级操作，因此在VM 2.2没有办法升级到当前版本，安装VM 3.0将会删除服务器上所有的数据。

将VM Server的光盘放入，并从光盘启动服务器。

在启动界面直输入Enter开始安装过程：

Oracle会提示是否监测截至，这里可以直接SKIP跳过；

键盘选择：选择us；

然后是版权声明，选择Accept后，开始正式的安装步骤；

如果服务器上没有系统，那么会直接进入后面的分区阶段，否则会提示重装系统还是在原有系统上升级；

选择ReInstall后，会显示当前系统磁盘分区信息，首先选择准备进行系统安装的分区，然后选择Remove tb all partitions and create a new default partition layout，Oracle在格式化分区之前会要求再次确认，并询问是否预览分区空间详细配置，可以完全按照默认推荐值安装，因此这里可以跳过，也可以进入到分区空间修改页面进行自定义的修改；

随后选择Boot Loader配置，选择Master Boot Record；

然后选择一个管理网络接口，手工输入IP和掩码，在下一个页面输入网关、DNS信息，接着是主机名信息；

配置服务器所在时区，配置中找不到北京，可以设置Asia/Shanghai代替；

分别输入Agent密码和root密码后，安装操作完成，这是会提示整个安装的日志文件的位置。

在重启界面选择REBOOT，完成整个安装过程。

启动后，进入Oracle VM Server 3.0控制台界面，可以通过Alt + F2进入linux的登录界面。至此VM Server安装完成。

posted @ 2012-09-03 17:10 chen11-1| 编辑 收藏

ORA-600(qersqCloseRem-2)错误

posted @ 2012-09-03 17:09 chen11-1 阅读(904) | 评论 (0) | 编辑 收藏

Oracle 11g R2的四个新增小特性总结

基于版本的重定义

Oracle 11g R2增加了一个强大的新工具，它可以检出应用程序数据库对象的任一版本，不是所有数据库对象都支持版本化管理，但私有的同义词，视图和几乎所有的PL/SQL对象，包括存储过程、函数、类型、类型主体、包、包主体和触发器，版本化管理的真正好处是简化了部署一个修改版本的应用程序代码到生产数据库，如果部署时遇到一系列的错误，可以很容易地将所有影响的对象回滚到上一个版本。

消除了闪回数据归档上的DDL限制

在前一篇文章中，我深入研究了Oracle 11g R1的新特性“闪回数据归档（Flashback Data Archive，FBDA）”，它也被称为“全部召回（Total Recall）”，它只捕获变化的数据，将这些数据放在一套特殊的对象中，它们构成了FBDA，当用户通过闪回版本查询（Flashback Versions query）查询表的历史记录时，Oracle将会直接从数据库的UNDO表空间返回最近变化的数据，从FBDA返回更旧的数据。

虽然这个特性很好，但在早期版本中也有很多限制，包括增加、修改、重命名、删除表的列、truncate表、修改表的约束、以及修改分区表的分区规范，在Oracle 11g R2中，这些限制全部没有了，对于更复杂的DDL操作，如使用DBMS_REDEFINITION包重定义已经存储到FBDA的基础表，Oracle 11g R2提供了新的DBMS_FLASHBACK_ARCHIVE包，存储过程DISASSOCIATE_FBA将会把基础表从FBDA中分离出来，一旦请求的改变完成，存储过程REASSOCIATE_FBA会被用来重新关联修改的表和基础表。

按需创建分段

在之前的版本中，使用CREATE TABLE语句创建表时，会同时自动创建表的初始段，从Oracle 11gR2开始，这个默认的行为有所变化，创建表时不会创建初始段，直到有数据插入到这个表。此外，任何依赖于该表的索引或LOB段也不会创建，直到有数据插入才会创建，表的SEGMENT CREATION DEFERRED存储属性指定了这个默认行为，但可以使用SEGMENT CREATION IMMEDIATE属性覆盖它。

不可用索引大小归零

在重新载入大表时，比如一个有上百万行的数据仓库事实表，要提高这种表的加载速度，最简单的办法是将该表上的所有索引置为不可用，在数据加载完毕后，在重建这些索引，Oracle 11g R2认可了这一做法，并采取了实质性的措施，tb当索引被标记为不可用时，它会自动删除所有索引段。

小结

Oracle 11g R2延续了自Oracle 10g以来令人称道的自我管理，自我调整，自我治愈的特性，这个新版本提供了太多的新特性，有些是迟来的功能，有些是革新，Oracle DBA可以借助这些新特性提高工作效率，成为一名真正的“信息工程师”。

posted @ 2012-08-31 08:10 chen11-1 阅读(284) | 评论 (0) | 编辑 收藏

Oracle 11g R2令人赞赏的五大新特性

2009年9月Oracle公司发布了期待已久的Oracle 11g R2，本系列文章将给读者一一揭开新版本中的新特性，并会介绍企业如何利用这些新特性将现有的Oracle 9i，10g，11g R1升级到Oracle 11g R2.

经历了难以忍受的长时间等待，Oracle公司突然在9月1发布了Oracle 11g R2，我不得不承认Oracle的保密工作做得多么好，我相信Oracle公司选择这个时候发布时为了刺激参加Oracle OpenWorld 2009大会的人兴奋和期待。

经过四处搜索Oracle 11g R2新特性文档，并体验了新的OUI(Oracle通用安装程序)，创建了我的第一个单实例RAC后，我总结一下Oracle 11g R2中我最喜欢的五大新特性。在后面的文章中我将陆续介绍其它新特性，请锁定本系列文章。

NO.1 随处可见的集群

在以前的版本中，Oracle Clusterware必须要独立地安装在它自己的ORACLE HOME中，并且也只能在RAC环境下使用，这一切在Oracle 11g R2得到彻底颠覆，因为在这个版本中支持安装Oracle网格基础架构，而且只需要一个独立的ORACLE HOME，它包括了Oracle Clusterware和Oracle自动存储管理(ASM)。通过升级后的Oracle通用安装程序安装了网格基础架构后，你将会看到一个全新的功能和服务矩阵，我简单地列举几个吧：

单实例RAC(Oracle重启)：听起来似乎自相矛盾，但Oracle 11g R2扩展了Oracle Clusterware的功能，为任何单实例提供了高可用特性，本质上是将数据库变成了单实例RAC数据库。Oracle 11g R2中的Oracle重启特性帮助Oracle网格基础架构的高可用服务控制服务器重启时哪一个监听器，ASM实例和数据库应该启动，它完全取代了过去DBA们经常用到的DBSTART脚本。同样，当单个数据库实例崩溃或其它异常终止时，Oracle重启功能会自动监测失效的实例，并自动重启它，就好像是在一个真实的RAC环境中一样。

SRVCTL升级：如果你管理过旧版本的RAC环境，你可能已经熟悉了RAC环境中的维护工具SRVCTL，在11g R2中，该工具被扩展了，现在可以管理单实例RAC，以及监听器和ASM实例。

集群时间同步服务：Oracle 11g R2现在需要在所有RAC节点上配置时间同步，如果你曾经经历过某个节点被驱逐出RAC集群配置，你一定知道其难度有多大，特别是两个服务器的时间不同步和日志文件的时间戳不同步时，Oracle之前的版本借助系统提供的网络时间协议(NTP)同步所有节点时间，但这需要连接到互联网上的标准时间服务器，作为NTP的替代者，Oracle 11g R2提供了一个新的集群时间同步服务，确保集群中的所有节点的时间都保持一致。

网格即插即用：在以前的版本中，配置RAC最复杂的部分是确定和设置所有节点都需要用到的公共ip地址，私有ip地址和虚拟ip地址。为了简化RAC的安装，Oracle 11g R2提供了一个全新的网格名称服务(GNS)，它和域名服务器协作，处理每个网格组件的ip地址分配，当集群环境跨越多个数据库时这个新特性极其有用。

干净地卸载RAC组件：如果你曾经尝试过删除多个节点上的所有RAC痕迹，那一定会钟情于这项新特性，在Oracle 11g R2中，所有安装和配置助手，特别是Oracle通用安装程序(OUI)，数据库配置助手(DBCA)和网络配置助手(NETCA)，都得到了增强，当需要卸载RAC组件时，可以保证卸得干干净净。

NO.2 ASM加入了集群

Oracle 11g R2 ASM充满了许多吸引人的新特性，对于初学者来说，ASM和Oracle 11g R2 Clusterware安装在同一个Oracle Home下，因此消除了之前推荐的冗余Oracle Home安装方法，并且ASM也从DBCA脱离出来了，有了专门的自动存储管理配置助手(ASMCA)。下面是我认为最有趣的ASM新特性：

智能化数据布局：在之前的版本中，要配置ASM磁盘可能需要存储管理员的参与，需要配置磁盘I/O子系统，Oracle 11g R2提供了ASM分配单元，可以直接受益于磁盘外缘柱面，获得更快的速度，可以将数据文件，重做日志文件和控制放在磁盘外缘获得更好的性能。

EM支持工作台扩展：在这个版本中对Oracle 11g R1引入到企业管理控制台中的自动诊断仓库(ADR)进行了扩展，包括支持ASM诊断，将所有诊断信息打包直接发送给Oracle技术支持，以便获得更快速的ASM性能问题解决方案。

ASMCMD增强：自动存储管理命令行实用工具(ASMCMD)也获得了不少增强，包括：

1)启动和停止ASM实例;

2)备份，恢复和维护ASM实例的服务器参数文件(spfile);

3)实用iostat监控ASM磁盘组的性能;

4)维护新的ASM集群文件系统(ACFS)中的磁盘卷，目录和文件存储，我的下一个话题就是它。

NO.3 ACFS – 一个强健的集群文件系统

Oracle之前也发布过集群文件系统(OCFS)，之后又发布了增强版OCFS2，它让Oracle RAC实例可以通过共享存储读写数据库文件，重做日志文件和控制文件。

此外，OCFS也允许RAC数据库的Oracle集群注册文件(OCR)和表决磁盘存储在集群文件系统中，在Oracle 10g R2中，这个需求被取消了，OCR文件和表决磁盘可以存储在裸设备或裸块设备中，如果你曾经在原始设备上丢失过这些文件的所有副本，你一定了解要恢复它们是多么繁琐，因此，在Oracle 11g R2中，将不再支持将这些文件存储在裸设备上。

为了提高这些关键文件的存活能力，Oracle 11g R2正式引入了一种新的集群文件系统，称之为ASM集群文件系统(ACFS)，在RAC环境中，ACFS可以为OCR文件和表决磁盘提供更好的保护，它允许创建五份OCR文件副本，tb之前的集群文件系统仅允许保存两份OCR文件，一个主OCR，一个镜像OCR，但ACFS不适合单独的RAC环境，除此之外，几乎所有与操作系统和数据相关的文件都可以从ACFS的安全性和文件共享特性受益。

动态卷管理器：Oracle 11g R2提供了一个新的ASM动态卷管理器(ADVM)来配置和维护存储在ACFS文件系统中的文件，使用ADVM可以在ASM磁盘组内构建一个ADVM卷设备，管理存储在ADVM卷设备中的文件，以及按需调整ADVM卷设备空间大小，最重要的是，因为ADVM是构建在ASM文件系统架构之上的，可以保证存储在这些卷中的文件受到良好的保护，不会出现意外丢失，因为ASM提供了类似RAID的磁盘阵列的功能。

文件访问控制：使用传统的Windows风格访问控制列表(ACL)或Unix/Linux下的用户/组/其它访问权限风格为ACFS目录和文件授予读，写和执行权限，可以通过图形化的企业管理控制台或命令行程序ASMCMD管理ACFS目录和文件安全。

文件系统快照(FSS)：Oracle 11g R2通过它的文件系统快照(FSS)功能可以对ACFS文件系统执行快照，一个快照是所选ACFS文件系统的一个只读副本，对相同的ACFS，它会自动保留63个独立的ACFS快照，当某个ACFS文件被不经意地更新，删除或其它危险操作时，这个特性非常有用，利用11g R2企业管理控制台或ACFS acfsutil命令行工具可以找出该文件合适的版本并执行恢复。

NO.4 改善的软件安装和打补丁过程

我发现作为一名DBA压力最大的活就是给Oracle数据库打补丁了，如果补丁可能会引入对数据库有害的行为，我不得不花费大量的时间和精力来确定和审核，因此我对Oracle 11g R2中提供的新功能感到很欢喜。

集群验证实用程序集成：从Oracle 10g开始引入了集群验证实用程序(CVU)，现在已经完全集成到Oracle通用安装程序(OUI)和其它配置助手(如DBCA，DBUA)中了。

零停机修补的集群：当为Oracle集群打补丁时，Oracle 11g R2在一个不合适的位置升级方式应用补丁，这意味着会有两个Oracle Home，其中一个专门用来存放补丁的，但一次只能激活一个Oracle Home，在Oracle 11g R2中不用再为升级全部关闭Oracle集群了，实现真正的零停机打补丁。

NO.5 DBMS_SCHEDULER升级

古老的DBMS_SCHEDULER包得到了彻底的更新，DBA经常使用这个包来调度作业。

文件监视器：以前的版本无法在批处理过程中检测大多数触发事件，如检测一个文件抵达某个目录，在Oracle 11g R2中，使用新的文件监视器可以缓解这个问题，一旦预期的文件抵达目录，DBMS_SCHEDULER现在就可以检测到了，并在新的对象类型SCHEDULER_FILEWATCHER_RESULT中注册它的到来，它通过新的CREATE_FILE_WATCHER存储过程向DBMS_SCHEDULER发送一个信号触发作业。

内置的email通知：无论何时，DBMS_SCHEDULER调度任务启动、失败或完成时，任务的状态可以立即通过email发送出去，虽然在以前的版本中也能实现这个功能，但要么调用DBMS_MAIL存储过程，要么调用DBMS_SMTP存储过程，现在这个功能合并到DBMS_SCHEDULER中了。

远程作业：DBMS_SCHEDULER现在允许DBA在远程数据库上创建和调度作业，现在我终于可以在生产库PROD03上通过DBMS_SCHEDULER调用生产库DBMS_SCHEDULER上的存储过程执行任务了，这意味着我现在可以在一台数据库上集中tb创建和维护调度任务了。

多作业目标：最后，现在可以在多个数据库实例上同时调度DBMS_SCHEDULER任务了，在RAC环境中，这个特性非常有用，因为我可以利用多个数据库实例将长时间运行任务分成几部分，分别在不同的数据库实例上执行更小的任务。

posted @ 2012-08-31 08:09 chen11-1| 编辑 收藏

详解DB2中自定义XML存储及其使用环境

使用IBM DB2 for z/OS和DB2 for Linux，UNIX和Windows (LUW)，那就没有问题，下面让我们一起回顾一下什么时候使用XML存储，以及如何自定义XML存储的一些最佳实践吧！

为了形象地说明，我将使用一个XML文档，内容如下：

<order OrderID="9001" OrderDate="2009-10-18">> 
 <customerID>26914</customerID> 
 <item id="LK-486"> 
  <name>Magictb Potion</name> 
  <size>300ml</size> 
  <price>19.99</price> 
 </item> 
 <item id="VF-145"> 
  <name>Crystal Ball, Deluxe</name> 
  <color>crystal clear</color> 
  <price>295.00</price> 
 </item> 
</order> 

它展示了一个包括订单ID，日期，客户ID和其它条目的订单XML文档，注意有些条目的描述方式有所不同，如size和color。我们假设需要在DB2中管理许多与此类似的XML文档。

如何拆分和重组XML

我在另一篇文章“15个DB2 pureXML性能最佳实践”中谈到了你应该明智地选择文档的粒度，实际上就是要将存储在DB2中的XML文档与应用程序的业务逻辑对象和主要的访问粒度匹配。

在我们的例子中，假设订单变化非常频繁，订单内的条目读取，添加或删除是最关键的操作，需要最佳的性能，在这种情况下，你可以考虑将订单文档拆分，将每一个条目作为一个独立的文档存储到DB2表的每一行中，这个存储方法（与原来的完整存储订单文档的方法相比）的好处是它使得操作所存储的数据更容易，更快速：

 

可以使用单行读取检索一个条目，不用从一个完整的订单文档中抽取条目了；

可以通过删除表中的行简单地从订单中删除一个条目，不再需要操作完整的订单文档；

可以迅速插入一个新条目到订单中，这时也不需要操作完整的订单文档。

这种轻松添加和移除订单条目的功能在DB2 9 for z/OS中尤其有价值，因为这个版本不支持在现有XML文档中添加或删除元素。
下面的代码显示了一个表的定义，以及拆分一个订单文档的INSERT语句，相关的列分别存储订单ID，客户ID，订单日期和一个条目流水号。

CREATE TABLE items(ordID INTEGER, custID INTEGER,  
                                   odate DATE, seqNo INTEGER, item XML);  
INSERT INTO items(ordID, custID, odate, seqno, item)  
 SELECT T.ordID, T.custID, T.odate, T.seqno, XMLDOCUMENT( T.item)  
 FROM 
  XMLTABLE('$d/order/item' PASSING cast(? AS XML) "d" 
   COLUMNS  
    ordID        INTEGER    PATH      '../@OrderID',  
    custID       INTEGER    PATH      '../customerID' 
    odate        DATE       PATH      '../@OrderDate',  
    seqNo        FOR ORDINALITY,  
    item         XML        PATH      '.') AS T; 

条目信息是以XML格式存储的，因为条目可能有不同的元素和属性，如：

 

ORDID     CUSTID     ODATE     SEQNO     ITEM  
-----     -----     ------     -----     -----  
9001     26914     10/18/2009     1   <item id="LK-486">  
                                        <name>Magic Potion</name>  
                                        <size>300ml</size>  
                                        <price>19.99</price>  
                                      </item>  
9001     26914     10/18/2009     2   <item id="VF-145">  
                                        <name>Crystal Ball, Deluxe</name>  
                                        <color>crystaltb clear</color>  
                                        <price>295.00</price>  
                                      </item>  
2 record(s) selected. 

INSERT语句包括一个XMLTABLE函数，这个函数从输入XML文档抽取插入items表中的值，它将会拆分输入XML文档，生成独立条目的文档。XMLTABLE函数包括一个参数，通过它，应用程序可以传递一个订单文档，使用XPath表达式$d/order/item，XMLTABLE函数为输入文档的每一个条目生成一行数据，然后抽取订单ID，客户ID和订单日期，特殊的列定义FOR ORDINALITY为产生的每一行打上编号。XMLDOCUMENT函数确保每一个条目片段可以作为一个独立的XML文档插入。

上面的代码显示了使用INSERT语句插入XML文档后items表中的数据，下面的代码显示了如何重建原始的订单文档，XMLELEMENT和XMLATTRIBUTES函数使用items表中相关列的值构建的顶部文档，XMLAGG函数组合所有条目，最后形成一个完整的订单文档。注意，XMLAGG在seqno列上包括一个可选的ORDER BY子句，这样可以确保还原后的订单文档和原始文档中的条目显示顺序是一致的。

 

SELECT XMLELEMENT(name "order",  
         XMLATTRIBUTES(ordID AS "OrderID", odate as "OrderDate"),  
         XMLELEMENT(name "customerID", custID)  
         XMLAGG(item ORDER BY seqno) )  
FROM items  
WHERE ordID = 9001  
GROUP BY ordID, odate, custID; 

使用生成列

DB2 9.7 for LUW中新的IBM DB2 pureXML特性允许你与数据库分区功能（Database Partitioning Feature，DPF），范围分区表和多维集群（MDC）表一起使用XML列，但分区或集群键必须由相关的列组成。前面你已经看到了如何使用INSERT和XMLTABLE从XML文档抽取值到相关的列中，你可以使用这些关联列对表进行分区或集群。如果你更喜欢在程序中使用简单的INSERT语句，并且不知道如何抽取数据时，那你可以考虑使用一个生成的列。

DB2 9.7在用户定义函数（UDF）中支持XML参数，允许你定义生成的列，使用插入的XML文档中的值自动填充。下面的代码显示了一个UDF，它接受一个XML文档作为输入，如前面例子中的订单文档，这个UDF使用XMLCAST和XMLQUERY函数抽取输入文档的OrderDate属性：

 

CREATE FUNCTION extractDate(doc XML)  
  RETURNS DATE 
  LANGUAGE SQL CONTAINS SQL  
  NO EXTERNAL ACTION DETERMINISTIC  
  RETURN XMLCAST(XMLQUERY('$d/order/@OrderDate' 
         PASSING doc AS "d") AS DATE); 

你可以在SELECT查询和其它SQL语句中使用这个UDF，但也要定义一个生成列，对于下面的示例，假设检索和插入完整的订单是最关键的操作，在这种情况下，完整地存储订单文档是最好的选择。下面的代码定义了一个使用XML列存储订单的表，并自动抽取订单日期填充到关联的列（odate）中。一条INSERT语句现在可以简单地插入一个XML文档到order列中，不需要考虑抽取值到关联列中：

CREATE TABLE orders(  
  order XML,  
  odate DATE GENERATED ALWAYS AS (extractDate(order))); 

如果你连续不断地存储许多订单，可能需要对旧订单进行归档，这个时候使用范围分区是最好的选择，下面的代码显示了表order2是通过按odate列的值进行分区的，odate列则产生自XML列，同样，你可以使用生成的列作为分区数据库的分配键，也可以作为MDC表的集群键：

CREATE TABLE order2(  
  order XML,  
  odate DATE GENERATED ALWAYS AS (extractDate(order)) NOT NULL)  
 PARTITION BY RANGE (odate)  
 (PART q109 STARTING('01-01-2009') ENDING ('03-31-2009') INCLUSIVE,  
 PART q209 ENDING ('06-30-2009') INCLUSIVE,  
 PART q309 ENDING ('09-30-2009') INCLUSIVE,  
 PART q409 ENDING ('12-31-2009') INCLUSIVE); 

控制XML存储

 

自定义XML存储有许多好处，将大型XML文档拆分成多个小文档，将会使操作XML数据变得更加容易和高效，使用UDF定义生成列可以简化XML值抽取到关联列，使用生成列还可以帮助你管理分区数据库，范围分区表，或MDC表中的XML。

原文出处：http://www.ibm.com/developerworks/data/library/dmmag/DMMag_2009_Issue3/Tips/index.html

原文名：Customizing XML storage in DB2

作者：Matthias Nicola

 

posted @ 2012-08-31 08:08 chen11-1 阅读(1859) | 评论 (0) | 编辑 收藏

ORA-1595和ORA-1594错误

posted @ 2012-08-30 13:10 chen11-1 阅读(874) | 评论 (0) | 编辑 收藏

ORA-600(1265)错误

客户的数据库出现ORA-600错误，错误函数为1265。

 

 

数据库版本为10.2.0.4 for Linux，错误信息为：

Fri Aug 26 22:00:11 2011
Errors in file /opt/app/oracle/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
Fri Aug 26 22:00:13 2011
Errors in file /opt/app/oracletb/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
Fri Aug 26 22:00:13 2011
Trace dumping is performing id=[cdmp_20110826220013]
Fri Aug 26 22:00:14 2011
Errors in file /opt/app/oracle/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-06512: at "USER1.P_PRO", line 5
ORA-04088: error during execution of trigger 'USER1.P_PRO'
Fri Aug 26 22:00:15 2011
Errors in file /opt/app/oracle/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-06512: at "USER1.P_PRO ", line 5
ORA-04088: error during execution of trigger 'USER1.P_PRO'
ORA-06512: at "USER1.U_PRO ", line 25
Fri Aug 26 22:00:17 2011
Errors in file /opt/app/oracle/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-02067: transaction or savepoint rollback required
Fri Aug 26 22:00:18 2011
Errors in file /opt/app/oracle/admin/orcl/udump/orcl1_ora_16655.trc:
ORA-00600: internal error code, arguments: [17281], [600], [0x2E134EEC0], [], [], [], [], []
ORA-00600: internal error code, arguments: [1265], [0x42180EA78], [], [], [], [], [], []
ORA-02067: transaction or savepoint rollback required

这个错误是ORA-600[1265]错误引发的，随后还出现了ORA-600[17281]、ORA-4088和ORA-2067错误。其中ORA-2067的描述为：

$ oerr ora 2067
02067, 00000, "transaction or savepoint rollback required"
// *Cause: A failure (typically a trigger or stored procedure with multiple
// remote updates) occurred such that the all-or-nothing execution
// of a previous Oracle call cannot be guaranteed.
// *Action: rollback to a previous savepoint or rollback the transaction
// and resubmit.

从这个描述和Oracle的报错信息不难判断，Oracle在通过触发器更新远端表时引发了这个600错误。

根据Oracle的MOS文档Bug 5655419 Distributed transaction hits ORA-600:[1265] or ORA-600:[k2gget: downgrade] in 10.2的描述，这个错误和分布式事务有关，确认影响的版本就是当前环境的10.2.0.4。这个错误的产生一般与窗口维护有关，可以看到问题的发生时刻恰好是22点，从这个时刻开始，Oracle进入维护窗口，进行空间回收统计信息收集等后台工作，显然就是因为窗口的变化导致了这个错误的产生。

Oracle在11.1.0.6中FIXED了这个bug。除了版本升级外，可以考虑将包含分布式事务修改的程序放到远离时间窗口改变时间。

posted @ 2012-08-30 13:09 chen11-1 阅读(1344) | 评论 (0) | 编辑 收藏

ORA-600(kccida_kccsgfsz)错误

posted @ 2012-08-30 13:08 chen11-1 阅读(219) | 评论 (0) | 编辑 收藏

分区表UNUSED列后的EXCHANGE PARTITION操作

碰到一个有意思的问题，如果分区表执行过SET UNUSED操作，那么是否还可以进行分区的EXCHANGE操作。

 

 

一个简单的测试就可以说明这个问题：

SQL> create table t_part_unused
 2 (id number, name varchar2(30), other varchar2(30))
 3 partition by range (id)
 4 (partition p1 values less than (10),
 5 partition pmax values less than (maxvalue));

Table created.

SQL> insert into t_part_unused
 2 select rownum, table_name, 'abc'
 3 from user_tables;

48 rows created.

SQL> commit;

Commit complete.

SQL> alter table t_part_unused set unused (other);

Table altered.

SQL> desc t_part_unused
 Name                                    Null?   Type
 ---------------------------------------- -------- ------------------------
 ID                                               NUMBER
 NAME                                             VARCHAR2(30)

SQL> create table t_temp_unused as
 2 select *
 3 from t_part_unused
 4 where 1 = 2;

Table created.

SQL> desc t_temp_unused
 Name                                    Null?   Type
 ---------------------------------------- -------- ------------------------
 ID                                               NUMBER
 NAME                                             VARCHAR2(30)

SQL> alter table t_part_unused
 2 exchange partition p1
 3 with table t_temp_unused;
with table t_temp_unused
          *
ERROR at line 3:
ORA-14097: column type or size mismatch in ALTER tb TABLE EXCHANGE PARTITION

SQL> alter table t_temp_unused add (other varchar2(30));

Table altered.

SQL> alter table t_part_unused
 2 exchange partition p1
 3 with table t_temp_unused;
with table t_temp_unused
          *
ERROR at line 3:
ORA-14096: tables in ALTER TABLE EXCHANGE PARTITION must have the same number of columns

SQL> alter table t_temp_unused set unused (other);

Table altered.

SQL> alter table t_part_unused
 2 exchange partition p1
 3 with table t_temp_unused;

Table altered.

很明显执行了SET UNUSED操作后的表，和普通的表是存在区别的，这种区别导致要求进行EXCHANGE的表必须同样执行SET UNUSED操作，否则就无法执行EXCHANGE的操作。

当目标表中不包含SETE UNUSED的列时，EXCHANGE操作会出现ORA-14097的错误，而如果把列添加到目标表，则会报错ORA-14096，必须在目标表同样对列执行SET UNUSED操作，才能通过EXCHANGE之前的检查。

其实这也不难理解，执行SET UNUSED命令后，数据字典虽然发生了改变，但是tb表上的数据并没有删除，而EXCHANGE操作只是将两个段的数据字典进行互换，因此如果目标表上缺少SET UNUSED列，是无法执行EXCHANGE操作的。

解决问题的方法有两个，第一个就是例子中展示的可以在目标表上建立列然后同样的执行SET UNUSED操作；另外的一个方法就是对于SET UNUSED列执行DROP COLUMN操作，彻底删除该列。

posted @ 2012-08-30 13:07 chen11-1 阅读(822) | 评论 (0) | 编辑 收藏

10g中DBA_TAB_STATISTICS的STATTYPE_LOCKED列对分区锁定显示为空

Oracle10g的DBA_TAB_STATISTICS视图的STATTYPE_LOCKED列没有正确的显示结果。

 

 

看一个简单的例子：

SQL> select * from v$version;

BANNER
----------------------------------------------------------------
Oracle Database 10g Enterprise Edition Release 10.2.0.5.0 - 64bi
PL/SQL Release 10.2.0.5.0 - Production
CORE 10.2.0.5.0 Production
TNS for Linux: Version 10.2.0.5.0 - Production
NLSRTL Version 10.2.0.5.0 - Production

SQL> create table t_part (id number, name varchar2(30))
 2 partition by range (id)
 3 (partition p1 values less than (10),
 4 partition p2 values less than (20),
 5 partition pmax values less than (maxvalue));

Table created.

SQL> select table_name, partition_name, stattype_locked from tb all_tab_statistics where wner = user and table_name = 'T_PART';

TABLE_NAME                     PARTITION_NAME                 STATT
------------------------------ ------------------------------ -----
T_PART
T_PART                         P1
T_PART                         P2
T_PART                         PMAX

SQL> exec dbms_stats.lock_partition_stats(user, 'T_PART', 'P1')

PL/SQL procedure successfully completed.

SQL> select table_name, partition_name, stattype_locked from all_tab_statistics where wner = user and table_name = 'T_PART';

TABLE_NAME                     PARTITION_NAME                 STATT
------------------------------ ------------------------------ -----
T_PART
T_PART                         P1
T_PART                         P2
T_PART                         PMAX

SQL> exec dbms_stats.gather_table_stats(user, 'T_PART')

PL/SQL procedure successfully completed.

SQL> select table_name, partition_name, last_analyzed, stattype_locked from all_tab_statistics where wner = user and table_name = 'T_PART';

TABLE_NAME                     PARTITION_NAME                 LAST_ANAL STATT
------------------------------ ------------------------------ --------- -----
T_PART                                                        16-JUL-12
T_PART                         P1
T_PART                         P2                             16-JUL-12
T_PART                         PMAX                           16-JUL-12

可以看到在10.2环境中，LOCK_PARTITION_STATS过程是正常工作的，但是DBA_TAB_STATISTICS视图的STATTYPE_LOCKED列并没有正确的显示分区被锁定的结果。

而对于表来说，LOCK_TABLE_STATS过程执行后，STATTYPE_LOCKED的结果显示是正常的：

SQL> exec dbms_stats.lock_table_stats(user, 'T_PART')

PL/SQL procedure successfully completed.

SQL> select table_name, partition_name, last_analyzed, stattype_locked from all_tab_statistics where wner = user and table_name = 'T_PART';

TABLE_NAME                     PARTITION_NAME                 LAST_ANAL STATT
------------------------------ ------------------------------ --------- -----
T_PART                                                        16-JUL-12 ALL
T_PART                         P1                                       ALL
T_PART                         P2                             16-JUL-12 ALL
T_PART                         PMAX                           16-JUL-12 ALL

这说明在10.2中，Oracle对于分区列的锁定的支持是存在问题的。查询了一下MOS，Oracle将这个问题确认为内部BUG：7240460，这个问题在11.1.0.7中被FIXED。

而在11.2中，这个问题以及不存在了：

SQL> select * from v$version;

BANNER
----------------------------------------------------------------------------
Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production
PL/SQL Release 11.2.0.3.0 - Production
CORE    11.2.0.3.0      Production
TNS for Solaris: Version 11.2.0.3.0 - Production
NLSRTL Version 11.2.0.3.0 - Production

SQL> select owner, table_name, partition_name, stattype_locked
 2 from dba_tab_statistics
 3 where wner = 'TEST'
 4 and table_name = 'T_PART';

OWNER      TABLE_NAME   PARTITION_NAME STATT
---------- ------------ --------------- -----
TEST       T_PART
TEST       T_PART       P2
TEST       T_PART       P3
TEST       T_PART       P4
TEST       T_PART       P5
TEST       T_PART       PMAX

6 rows selected.

SQL> exec dbms_stats.lock_partition_stats('TEST', 'T_PART', 'P2')

PL/SQL procedure successfully completed.

SQL> select owner, table_name, partition_name, stattype_locked
 2 from dba_tab_statistics
 3 where wner = 'TEST'
 4 and table_name = 'T_PART';

OWNER      TABLE_NAME   PARTITION_NAME STATT
---------- ------------ --------------- -----
TEST       T_PART
TEST       T_PART       P2              ALL
TEST       T_PART       P3
TEST       T_PART       P4
TEST       T_PART       P5
TEST       T_PART       PMAX

6 rows selected

posted @ 2012-08-29 15:27 chen11-1| 编辑 收藏

ORA-4031导致CJQ进程出现ORA-1003错误

客户数据库出现ORA-4031错误，随后出现了大量的ORA-1003和ORA-604错误。

 

 

数据库版本为10.2.0.3 RAC for HP-UX，详细的报错信息为：

Mon Jul 16 15:30:30 2012
Errors in file /u01/app/oracle/admin/ORCL/udump/orcl2_ora_2389.trc:
ORA-00603: ORACLE server session terminated by fatal error
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 32 bytes of shared memory ("shared pool","select name,online$,contents...","sql area","tmp")
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 32 bytes of shared memory ("shared pool","select name,online$,contents...","sql area","tmp")
Mon Jul 16 15:30:32 2012
Errors in file /u01/app/oracle/admin/ORCL/udump/orcl2_ora_2878.trc:
ORA-00603: ORACLE server session terminated by fatal error
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 144 bytes of shared memory ("shared pool","select name,online$,contents...","Typecheck","coldef: qcopCreateCol")
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 144 bytes of shared memory ("shared pool","select name,online$,contents...","Typecheck","coldef: qcopCreateCol")
Mon Jul 16 15:30:32 2012
Errors in file /u01/app/oracle/admin/ORCL/udump/orcl2_ora_10030.trc:
ORA-00603: ORACLE server session terminated by fatal error tb
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 144 bytes of shared memory ("shared pool","select name,online$,contents...","Typecheck","coldef: qcopCreateCol")
ORA-00604: error occurred at recursive SQL level 1
ORA-04031: unable to allocate 144 bytes of shared memory ("shared pool","select name,online$,contents...","Typecheck","coldef: qcopCreateCol")
Mon Jul 16 15:30:39 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-04031: unable to allocate 32 bytes of shared memory ("shared pool","select o.owner#,o.name,o.nam...","sql area","kobjn : kkdcchs")
Mon Jul 16 15:30:40 2012
Trace dumping is performing id=[cdmp_20120716153040]
Mon Jul 16 15:32:19 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:33:59 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:35:39 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:37:19 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:39:00 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:40:40 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQ
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: err
Mon Jul 16 15:41:59 2012
Thread 2 advanced to log sequence 61522
Current log# 7 seq# 61522 mem# 0: +ORCL_CTL/orcl/onlinelog/group_7.263.611598065
Mon Jul 16 15:42:20 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:44:00 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
Mon Jul 16 15:45:40 2012
Errors in file /u01/app/oracle/admin/ORCL/bdump/orcl2_cjq0_29269.trc:
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQ
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: error occurred at recursive SQL level 2
ORA-01003: no statement parsed
ORA-00604: error occurred at recursive SQL level ORA-00604: err

可以看得，开始还是比较“正常”的ORA-4031错误，但是随着CJQ进程出现了ORA-4031的错误，数据库开始每1分40秒报一次ORA-1003和ORA-604的错误。这里CJQ进程似乎陷入了一个死循环中，持续不停的报错。查询MOS发现，在9.2中Oracle存在类似的BUG：Bug 3289063 ORA-1003 every 5 seconds after CJQ hits ORA-4031。这个bug已经在9.2.0.5和10.1.0.2中被FIXED，但是这个bug的现象和当前的错误完全一致，从这点上看，这个问题显然在10.2.0.3中仍然存在。

Oracle给出的解决方案也很简单，重启CJQ进程既可。除了在操作系统去kill -9杀掉cjq0对应的进程之外，直接通过alter system set job_queue_processes=0，然后在设置回原值，也有可能解决该问题。此外，尽量避免ORA-4031错误的产生是最根本的问题解决之道。

posted @ 2012-08-29 15:17 chen11-1| 编辑 收藏

利用tar向磁带备份恢复文件

posted @ 2012-08-29 15:16 chen11-1 阅读(192) | 评论 (0) | 编辑 收藏

密码即将过期提示的影响

当用户密码即将过期时，在登录时Oracle会提示ORA-28002错误，但是并不会影响正常的登录。

 

 

本来认为这个信息并没有太大的影响，但是没想到这个错误会导致SET AUTOTRACE功能失效：

solaris*orcl-/home/oracle$ sqlplus test/test

SQL*Plus: Release 11.2.0.3.0 Production on Fri Jul 13 11:27:28 2012

Copyright (c) 1982, 2011, Oracle. tb All rights reserved.

ERROR:
ORA-28002: the password will expire within 1 days

Connected to:
Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production
With the Partitioning, Oracle Label Security and Real Application Testing options

SQL> set autot on
ERROR:
ORA-28002: the password will expire within 1 days

SP2-0619: Error while connecting
SP2-0611: Error enabling STATISTICS report
SQL> alter user test identified by test;

User altered.

SQL> set autot on
ERROR:
ORA-24315: illegal attribute type

SP2-0619: Error while connecting
SP2-0611: Error enabling STATISTICS report
SQL> exit
Disconnected from Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production
With the Partitioning, Oracle Label Security and Real Application Testing options
solaris*orcl-/home/oracle$ sqlplus test/test

SQL*Plus: Release 11.2.0.3.0 Production on Fri Jul 13 11:27:52 2012

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

Connected to:
Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production
With the Partitioning, Oracle Label Security and Real Application Testing options

SQL> set autot on
SQL> insert into t values (1, 'a');

1 row created.

Execution Plan
----------------------------------------------------------

---------------------------------------------------------------------------------
| Id | Operation                | Name | Rows | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------
|   0 | INSERT STATEMENT         |      |     1 |    12 |  tb   1   (0)| 00:00:01 |
|   1 | LOAD TABLE CONVENTIONAL | T    |       |       |            |          |
---------------------------------------------------------------------------------

Statistics
----------------------------------------------------------
         71 recursive calls
          9 db block gets
         75 consistent gets
         10 physical reads
       1284 redo size
        829 bytes sent via SQL*Net to client
        785 bytes received via SQL*Net from client
          3 SQL*Net roundtrips to/from client
          9 sorts (memory)
          0 sorts (disk)
          1 rows processed

很显然，由于ORA-28002错误导致了SET AUTOTRACE ON功能启用时碰到了错误。当修改了当前的用户密码，则ORA-28002不再出现后，SET AUTOTRACE ON的功能恢复正常。

根据上面的信息其实可以判断，在启用SET AUTOTRACE ON功能时，sqlplus会自动创建一个新的会话来记录当前会话的统计信息。

而启用的新的会话会使用当前会话登录时保存的密码来进行登录，因此可以通过下面的例子来验证这个推论：

solaris*orcl-/home/oracle$ sqlplus test/test

SQL*Plus: Release 11.2.0.3.0 Production on Sun Jul 15 01:28:38 2012

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

Connected to:
Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production
With the Partitioning, Oracle Label Security and Real Application Testing options

SQL> set autot on
SQL> set autot off
SQL> alter user test identified by test1;

User altered.

SQL> set autot on
ERROR:
ORA-01017: invalid username/password; logon denied

SP2-0619: Error while connecting
SP2-0611: Error enabling STATISTICS report

果然，在用户登录后，如果当前的密码被修改，是会导致SET AUTOTRACE ON启用时报错不正确的用户名密码错误的。

posted @ 2012-08-29 15:15 chen11-1| 编辑 收藏

分区表部分分区不可用导致统计信息收集失效

posted @ 2012-08-27 14:36 chen11-1| 编辑 收藏

ORA-600(kffmXpGet)错误

第一次碰到Exadata上的bug。

 

 

数据库环境Exadata V2-2，数据库版本为11.2.0.2，错误信息为：

Wed Apr 25 11:32:35 2012
Errors in file /u01/app/oracle/diag/rdbms/ods/orcl2/trace/orcl2_ora_9495.trc (incident=304808):
ORA-00600: internal error code, arguments: [kffmXpGet], [145], [69784], [], [], [], [], [], [], [], [], []
ORA-03135: connection lost contact
Incident details in: /u01/app/oracle/diag/rdbms/orcl/orcl2/incident/incdir_304808/orcl2_ora_9495_i304808.trc
Use ADRCI or Support Workbench to package the incident.
See Note 411.1 at My Oracle Support for error and packaging details.
opidcl aborting process tb unknown ospid (9495) as a result of ORA-600
Wed Apr 25 11:32:36 2012
Dumping diagnostic data in directory=[cdmp_20120425113236], requested by (instance=2, sid=9495), summary=[incident=304808].
Wed Apr 25 11:32:36 2012
Sweep [inc][304808]: completed
Sweep [inc2][304808]: completed
Wed Apr 25 11:32:39 2012
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl2/trace/orcl2_pmon_10797.trc (incident=302224):
ORA-00600: internal error code, arguments: [kffmXpGet], [181], [87276], [], [], [], [], [], [], [], [], []
Incident details in: /u01/app/oracle/diag/rdbms/orcl/orcl2/incident/incdir_302224/orcl2_pmon_10797_i302224.trc
Dumping diagnostic data in directory=[cdmp_20120425113240], requested by (instance=2, sid=10797 (PMON)), summary=[incident=302224].
Use ADRCI or Support Workbench to package the incident.
See Note 411.1 at My Oracle Support for error and packaging details.
Errors in file /u01/app/oracle/diag/rdbms/orcl/orcl2/trace/orcl2_pmon_10797.trc:
ORA-00600: internal error code, arguments: [kffmXpGet], [181], [87276], [], [], [], [], [], [], [], [], []
PMON (ospid: 10797): terminating the instance due to error 472
Wed Apr 25 11:32:41 2012
opiodr aborting process unknown ospid (11248) as a result of ORA-1092
Wed Apr 25 11:32:41 2012
opiodr aborting process unknown ospid (1967) as a result of ORA-1092
Wed Apr 25 11:32:42 2012
ORA-1092 : opitsk aborting process
Wed Apr 25 11:32:43 2012
License high water mark = 573
Instance terminated by PMON, pid = 10797
USER (ospid: 8755): terminating the instance
Instance terminated by USER, pid = 8755

由于ORA-600[kffmXpGet]错误的出现，最终出现了ORA-1092的错误，并致使opitsk进程退出，导致数据库实例崩溃。

Oracle在MOS文档Bug 12387467 instance crash by ORA-600 [kffmxpget]中描述了这个问题，确认影响的版本为11.2.0.1、11.2.0.2、11.2.0.3，Oracle在11.2.0.2的Bundle Patch 16 for Exadata以及11.2.0.3 Bundle Patch 5 for Exadata中fixed了这个问题，Oracle计划在11.2.0.4和12.1中彻底Fixed该问题。

这个错误只会发生在Exadata中，因为导致错误的原因和Smart Scan有关。当会话执行Smart Scan操作时使用了Ctrl + C中止该操作，会导致PMON进程出现这个600错误。Oracle建议在执行数据文件的SHRINK操作前，中止并退出所有执行Exadata Smart Scan的会话。

posted @ 2012-08-27 14:34 chen11-1| 编辑 收藏