]]>
//*********创建实例***********
type t = typeof(classtest);//表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数...。
object obj = activator.createinstance(t);//通过反射创建对象实例,如果是静态类则不须实例化
//obj = ass.createinstance("reflectiontest.classtest"); //类的全限定名.命名空间.类名
//*********创建和调用方法***********
methodinfo method = t.getmethod("writestring"); //搜索具有指定名称的公共方法。
string s = (string)method.invoke(obj, new object[] { "123" });//反射类的对象实例,方法参数
//静态方法
method = type.getmethod("staticwritestring");
method.invoke(null, new string[] { "test" }); //如果是静态方法,第1个参数则忽略,设为null
//无参的静态方法
method = type.getmethod("noneparawritestring");
method.invoke(null, null);//无参则第2个参数设为null.
system.diagnostics.trace.writeline(s);//输出到"调试--窗口--即时窗口"
c#反射学习时几点注意内容：
1．指定类库文件必须使用绝对路径，不能使用相对路径（其实感觉有点不合理，不太方便）
3．第5行如果反射的类使用的是静态方法,则第1个参数须调为null。
4．由于这个方法有两个参数，可以用这种object的方法指定参数也可以直接写method.invoke(obj, new object[] { "test", 1 });
5．调用的方法是一个静态方法，这时候invoke的时候，对于第一个参数是无视的，也就是我们写什么都不会被调用，即使我们随便new了一个any这样的object，当然这种写法是不推荐的。但是对应在例子1种我们如果invoke的时候用了类型不一致的实例来做为参数的话，将会导致一个运行时的错误。
6．第三个例子是一个调用无参数静态方法的例子，这时候两个参数我们都不需要指定，用null就可以了。
再说一个问题，如果调用的类是静态类的时候，需要注意一个问题，肯定我们会想到一个问题，静态类是不能实例化的，这时候，31行的类的实例化的方法我们就不需要了，直接使用invoke就可以实现，否则将会出现运行时的错误，同样的道理，第一个参数将会被无视，只要我们传对了参数就可以了。
]]>
{
text : '下载导入模板',
iconcls : 'import',
handler : function() {
window.location.href="../buinessplandownloadservlet";
}
}
java:
package com.sysware.customize.hd.investment.productionmaterialsmanagement.buinessplan;
import java.io.bufferedinputstream;
import java.io.bufferedoutputstream;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.printwriter;
import javax.servlet.servletexception;
import javax.servlet.servletoutputstream;
import javax.servlet.http.httpservlet;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
public class buinessplandownservlet extends httpservlet {
private static final long serialversionuid = 1l;
protected void doget(httpservletrequest request,
httpservletresponse response) throws servletexception, ioexception {
this.dopost(request, response);
}
protected void dopost(httpservletrequest request,
httpservletresponse response) throws servletexception, ioexception {
string filepath = request.getsession().getservletcontext().getrealpath("") file.separator "template.files" file.separator "buinessplandown" file.separator "buinessplantempl.xls";
response.reset();
response.setcharacterencoding("utf-8");
file file = new file(filepath);
if (!file.exists()) {
printwriter out = response.getwriter();
out.print("{failure:true}");
return;
}
response.setcontenttype("application/x-msdownload");
response.setheader("content-disposition", "attachment;filename=" new string(file.getname().getbytes("gb2312"), "iso8859-1"));
servletoutputstream out = response.getoutputstream();
bufferedinputstream bis = new bufferedinputstream(new fileinputstream(filepath));
bufferedoutputstream bos = new bufferedoutputstream(out);
byte[] buff = new byte[2048];
int bytesread;
while (-1 != (bytesread = bis.read(buff, 0, buff.length))) {
bos.write(buff, 0, bytesread);
}
if (bis != null) {
bis.close();
}
if (bos != null) {
bos.flush();
bos.close();
}
}
}
]]>
]]>
二、中国大陆镜像部分
china cmcc taian branch（泰安移动）
china netease（163网易）
china northeastern university, shenyang liaoni（东北大学）
china sohu inc, beijing p.r. china（搜狐centos镜像）
china star studio of uestc（电子科技大）
china university of science and tech of china（中科大）
此外，还有香港、台湾centos镜像地址也很快，具体参见上文官方网页，搜索hong kong或taiwan。
三、centos免费还是收费的？
参照《》一文说法：
“centos 并不向用户提供商业支持，当然也不负上任何商业责任。”，所以：
centos各版本系统都是免费下载和使用的，但是要获得支持或者某些定制软件，也可能是需求，则要付费。
四、centos livecd、livedvd和bindvd区别在哪里？
bindvd版——就是普通安装版，需安装到计算机硬盘才能用，bin一般都比较大，而且包含大量的常用软件，安装时无需再在线下载（大部分情况）。
livedvd版——就是一个光盘centos系统，可通过光盘启动电脑，启动出centos系统，也有图形界面，也有终端。也可以安装到计算机，但是有些内容可能还需要再次到网站下载（自动）。
livecd版——相比livedvd是个精简的光盘centos系统。体积更小，便于维护使用。
此外，还有个更mini的centos系统版本，上文中的centos-6.0-i386-minimal.iso就是，再下面的是网络安装版，你懂的，肯定难用。
名词：
srpms——source rpm
rpm——red hat package manager
更多参考：
官方凯发k8网页登录主页:
邮件列表:
论坛:
文档:
wiki:
镜像列表:
-------------------------------------------------------------------------------------------------------------
centos（community enterprise operating system）是linux发行版之一，它是来自于red hat enterprise linux依照开放源代码规定释出的源代码所编译而成。由于出自同样的源代码，因此有些要求高度稳定性的以centos替代商业版的red hat enterprise linux使用。两者的不同，在于centos并不包含封闭源代码软件。
概述
centos，我们有很多人叫它社区企业操作系统，不管你怎么叫它，它都是linux的一个发行版本。centos是企业linux发行版领头羊red hat enterprise linux（以下称之为rhel）的再编译版本，rhel是很多企业采用的linux发行版本，需要向redhat付费才可以使用，并能得到付过费用的服务和凯发k8网页登录的技术支持和版本升级。这个centos可以像rehl一样的构筑linux系统环境，但不需要向redhat付任何的费用，同样也得不到任何有偿凯发k8网页登录的技术支持和升级服务。典型的centos用户包括这样一些组织和个人，他们并不需要专门的商业支持就能开展成功的业务。centos面向那些需要企业级操作系统稳定性，但并不想负担认证和支持方面开销的人。
centos计划是在2003年红帽决定不再提供免费的凯发k8网页登录的技术支持及产品认证之后的部份"红帽重建者"（red hat rebuilders）之一。 centos和科学linux （scientific linux）、甲骨文linux（oracle linux）、费米linux（fermi linux）等都以红帽所发布的源代码去除商标重建red hat enterprise linux的翻版，并修正了已经发现了的redhat的bug。 centos是"caos linux"独立计划的一个分枝，在lawrence berkeley 国家实验室担任管理员与程序设计师的kurtzer 表示。但后来caos基金会最受欢迎的计划变成是rhel的重建。
历史
red hat公司的产品中，有redhat linux（如redhat8,9）和针对企业发行的版本red hat enterprise linux，都能够通过网络ftp免费的获得并使用，但是在2003年的时候，redhat com发布redhat 9(简写为rh9)后，不再开发redhat 10，11……，全面转向redhat enterprise linux(简写为rhel)的开发，和以往不同的是，新的rhel 3要求用户先购买lisence，redhat com承诺保证产品的稳定性，安全性。rhel 3二进制代码不再提供下载，而是作为redhat 服务的一部分，但源代码依然是open。它的项目由fedora project这个项目所取代，并以fedora core这个名字发行并提供普通用户免费使用（自fedora 7开始去掉"core"）。fedora core这个linux发行版更新很快，大约半年左右就有新的版本出来，目前的版本是fedora 15，这个fedora试验的韵味比较浓厚，每次发行都有新的功能被加入到其中，得到的成功结果将被采用到rhel的发布中。虽说这样，频繁的被改进更新的不安定产品对于企业来说并不是最好的选择，大多数企业还是会选择有偿的rhel产品。 在构成rhel的大多数软件包中，都是基于gpl协议发布的，也就是我们常说的开源软件，正因为是这样，red hat公司也遵循这个协议，将构成rhel的软件包公开发布，只要是遵循gpl协议，任何人都可以在原有的软件构成的基础上再开发和发布。centos就是这样在rhel发布的基础上将rhel的构成克隆再现的一个linux发行版本。rhel的克隆版本不只centos一个，还有oracle linux，scientific linux，fermi linux等。。但并不保障对应rhel的软件在centos上面能也够100%的正常工作。并且安全漏洞的修正和软件包的升级对应rhel的有偿服务和凯发k8网页登录的技术支持来说，数日数星期数个月的延迟情况也有。
]]>
prototype:原型.此对象的所有实例共享原型定义的数据和(对象)引用.一般用于防止重复创建函数,浪费内存.
原型中定义的所有函数和引用的对象都只创建一次;构造函数中的方法则会随着实例的创建重复创建(如果有对象或方法的话).
不管在原型中还是构造函数中,属性(值)都不共享.
创建类的最好方式是用构造函数定义属性，用原型定义方法。
这种方式同样适用于继承机制，用对象冒充继承构造函数的属性，用原型链继承 prototype 对象的方法。
//构造函数
function car(scolor,idoors,impg) {
this.color = scolor; //定义属性
this.doors = idoors; //定义属性
this.mpg = impg; //定义属性
this.drivers = new array("mike","john");//定义数组对象.每个实例创建一个单独的对象
}
//公共方法(共享),属性不共享.
car.prototype={
value:1, //属性不共享
objs:new array("a","b"), //对象共享引用
showcolor : function() { //方法共享引用.
alert(this.color);
}
};
var ocar1 = new car("red",4,23);
var ocar2 = new car("blue",3,25);
ocar1.drivers.push("bill"); //构造方法中的对象都是各个独立的.
ocar1.value=2; //属性不共享.
ocar1.objs.push('c'); //原型中的对象都是共享引用的.
document.write(ocar1.drivers "
" );
" );
//mike1,john,bill
ocar1.showcolor(); //red
document.write(ocar2.objs "
" );
" );
//a,b ocar1:a,b,c
document.write( "
" ocar2.value); //1
" ocar2.value); //1
document.write( "
" ocar2.drivers); //mike1,john
" ocar2.drivers); //mike1,john
]]>
]]>
使用 pycharm 开发 django 时，在settings.py的installed_apps中只需要添加app名就可以了，即:'mysite',
如果输入"django_example.mysite",则报错：
error: no module named mysite
]]>
依赖 （dependency）：元素a的变化会影响元素b，但反之不成立，那么b和a的关系是依赖关系，b依赖a；类属关系和实现关系在语义上讲也是依赖关 系，但由于其有更特殊的用途，所以被单独描述。uml中用带箭头的虚线表示dependency关系，箭头指向被依赖元素。
泛化（generalization）：通常所说的继承（特殊个体 is kind of 一般个体）关系，不必多解释了。uml中用带空心箭头的实线线表示generalization关系，箭头指向一般个体。
实现（realize）：元素a定义一个约定，元素b实现这个约定，则b和a的关系是realize，b realize a。这个关系最常用于接口。uml中用空心空心箭头和虚线表示realize关系，箭头指向定义约定的元素。
关联（association）：元素间的结构化关系，是一种弱关系，被关联的元素间通常可以被独立的考虑。uml中用实线表示association关系，箭头指向被依赖元素。
聚合（aggregation）：关联关系的一种特例，表示部分和整体（整体 has a 部分）的关系。uml中用带空心菱形头的实线表示aggregation关系，菱形头指向整体。
组 合（composition）：组合是聚合关系的变种，表示元素间更强的组合关系。如果是组合关系，如果整体被破坏则个体一定会被破坏，而聚合的个体则可 能是被多个整体所共享的，不一定会随着某个整体的破坏而被破坏。uml中用带实心菱形头的实线表示composition关系，菱形头指向整体。
其中依赖（dependency）的关系最弱，而关联（association），聚合（aggregation），组合（composition）表示的关系依次增强。换言之关联，聚合，组合都是依赖关系的一种，聚合是表明对象之间的整体与部分关系的关联，而组合是表明整体与部分之间有相同生命周期关系的聚合。
而关联与依赖的关系用一句话概括下来就是，依赖描述了对象之间的调用关系，而关联描述了对象之间的结构关系。
后面的例子将针对某个具体目的来独立地展示各种关系。虽然语法无误，但这些例子可进一步精炼，在它们的有效范围内包括更多的语义。
依赖（dependency）
实体之间一个“使用”关系暗示一个实体的规范发生变化后，可能影响依赖于它的其他实例（图d）。 更具体地说，它可转换为对不在实例作用域内的一个类或对象的任何类型的引用。其中包括一个局部变量，对通过方法调用而获得的一个对象的引用（如下例所 示），或者对一个类的静态方法的引用（同时不存在那个类的一个实例）。也可利用“依赖”来表示包和包之间的关系。由于包中含有类，所以你可根据那些包中的 各个类之间的关系，表示出包和包的关系。
图d
关联（association）
实体之间的一个结构化关系表明对象是相互连接的。箭头是可选的，它用于指定导航能力。如果没有箭头，暗示是一种双向的导航能力。在java中，关联（图e） 转换为一个实例作用域的变量，就像图e的“java”区域所展示的代码那样。可为一个关联附加其他修饰符。多重性（multiplicity）修饰符暗示 着实例之间的关系。在示范代码中，employee可以有0个或更多的timecard对象。但是，每个timecard只从属于单独一个 employee。
图e
聚合（aggregation）
聚合（图f）是关联的一种形式，代表两个类之间的整体/局部关系。聚合暗示着整体在概念上处于比局部更高的一个级别，而关联暗示两个类在概念上位于相同的级别。聚合也转换成java中的一个实例作用域变量。
关联和聚合的区别纯粹是概念上的，而且严格反映在语义上。聚合还暗示着实例图中不存在回路。换言之，只能是一种单向关系。
图f
合成（composition）
合成 （图g） 是聚合的一种特殊形式，暗示“局部”在“整体”内部的生存期职责。合成也是非共享的。所以，虽然局部不一定要随整体的销毁而被销毁，但整体要么负责保持局 部的存活状态，要么负责将其销毁。局部不可与其他整体共享。但是，整体可将所有权转交给另一个对象，后者随即将承担生存期职责。
employee和timecard的关系或许更适合表示成“合成”，而不是表示成“关联”。
图g
泛化（generalization）
泛化（图h）表示一个更泛化的元素和一个更具体的元素之间的关系。泛化是用于对继承进行建模的uml元素。在java中，用extends关键字来直接表示这种关系。
图h
实现（realization）
实例（图i）关系指定两个实体之间的一个合同。换言之，一个实体定义一个合同，而另一个实体保证履行该合同。对java应用程序进行建模时，实现关系可直接用implements关键字来表示。
图i
转自:
]]>
异或运算：相同为0，不同为1 与运算：两者为1时为1，有0为0 或运算：有1为1
(2)ip网段的计算和划分
ip和子网掩码 我们都知道，ip是由四段数字组成，在此，我们先来了解一下3类常用的ip
a类ip段 0.0.0.0 到127.255.255.255
b类ip段 128.0.0.0 到191.255.255.255
c类ip段 192.0.0.0 到223.255.255.255
xp默认分配的子网掩码每段只有255或0
a类的默认子网掩码 255.0.0.0 一个子网最多可以容纳1677万多台电脑
b类的默认子网掩码 255.255.0.0 一个子网最多可以容纳6万台电脑
c类的默认子网掩码 255.255.255.0 一个子网最多可以容纳254台电脑
我以前认为，要想把一些电脑搞在同一网段，只要ip的前三段一样就可以了，今天，我才知道我错了。如果照我这说的话，一个子网就只能容纳254台电脑？真是有点笑话。我们来说详细看看吧。
要想在同一网段，只要网络标识相同就可以了，那要怎么看网络标识呢？首先要做的是把每段的ip转换为二进制。（有人说，我不会转换耶，没关系，我们用windows自带计算器就行。打开计算器，点查看>科学型，输入十进制的数字，再点一下“二进制”这个单选点，就可以切换至二进制了。）
把子网掩码切换至二进制，我们会发现，所有的子网掩码是由一串连续的1和一串连续的0组成的（一共4段，每段8位，一共32位数）。
255.0.0.0 11111111.00000000.00000000.00000000
255.255.0.0 11111111.11111111.00000000.00000000
255.255.255.0 11111111.11111111.11111111.00000000
这是a/b/c三类默认子网掩码的二进制形式，其实，还有好多种子网掩码，只要是一串连续的1和一串连续的0就可以了（每段都是8位）。如11111111.11111111.11111000.00000000，这也是一段合法的子网掩码。子网掩码决定的是一个子网的计算机数目，计算机公式是2的m次方，其中，我们可以把m看到是后面的多少颗0。如255.255.255.0转换成二进制，那就是11111111.11111111.11111111.00000000，后面有8颗0，那m就是8，255.255.255.0这个子网掩码可以容纳2的8次方（台）电脑，也就是256台，但是有两个ip是不能用的，那就是最后一段不能为0和255，减去这两台，就是254台。我们再来做一个。
255.255.248.0这个子网掩码可以最多容纳多少台电脑？ 计算方法： 把将其转换为二进制的四段数字（每段要是8位，如果是0，可以写成8个0，也就是00000000） 11111111.1111111.11111000.00000000 然后，数数后面有几颗0，一共是有11颗，那就是2的11次方，等于2048，这个子网掩码最多可以容纳2048台电脑。
一个子网最多可以容纳多少台电脑你会算了吧，下面我们来个逆向算法的题。 一个公司有530台电脑，组成一个对等局域网，子网掩码设多少最合适？ 首先，无疑，530台电脑用b类ip最合适（a类不用说了，太多，c类又不够，肯定是b类），但是b类默认的子网掩码是255.255.0.0，可以容纳6万台电脑，显然不太合适，那子网掩码设多少合适呢？我们先来列个公式。 2的m次方＝560 首先，我们确定2一定是大于8次方的，因为我们知道2的8次方是256，也就是c类ip的最大容纳电脑的数目，我们从9次方一个一个试2的9次方是512，不到560，2的10次方是1024，看来2的10次方最合适了。子网掩码一共由32位组成，已确定后面10位是0了，那前面的22位就是1，最合适的子网掩码就是：11111111.11111111.11111100.00000000，转换成10进制，那就是255.255.252.0。 分配和计算子网掩码你会了吧，下面，我们来看看ip地址的网段。 相信好多人都和偶一样，认为ip只要前三段相同，就是在同一网段了，其实，不是这样的，同样，我样把ip的每一段转换为一个二进制数，这里就拿ip：192.168.0.1，子网掩码：255.255.255.0做实验吧。 192.168.0.1 11000000.10101000.00000000.00000001 （这里说明一下，和子网掩码一样，每段8位，不足8位的，前面加0补齐。） ip 11000000.10101000.00000000.00000001 子网掩码 11111111.11111111.11111111.00000000 在这里，向大家说一下到底怎么样才算同一网段。 要想在同一网段，必需做到网络标识相同，那网络标识怎么算呢？各类ip的网络标识算法都 是不一样的。a类的，只算第一段。b类，只算第一、二段。c类，算第一、二、三段。 算法只要把ip和子网掩码的每位数and就可以了。
and方法：0和1＝0 0和0＝0 1和1＝1 如：and 192.168.0.1，255.255.255.0，先转换为二进制，然后and每一位 ip 11000000.10101000.00000000.00000001 子网掩码 11111111.11111111.11111111.00000000 得出and结果 11000000.10101000.00000000.00000000 转换为十进制192.168.0.0，这就是网络标识， 再将子网掩码反取，也就是00000000.00000000.00000000.11111111，与ip and 得出结果00000000.00000000.00000000.00000001，转换为10进制，即0.0.0.1， 这0.0.0.1就是主机标识。要想在同一网段，必需做到网络标识一样。 我们再来看看这个改为默认子网掩码的b类ip 如ip：188.188.0.111，188.188.5.222，子网掩码都设为255.255.254.0，在同一网段吗？ 先将这些转换成二进制 188.188.0.111 10111100.10111100.00000000.01101111 188.188.5.222 10111100.10111100.00000101.11011010 255.255.254.0 11111111.11111111.11111110.00000000 分别and，得 10111100.10111100.00000000.00000000 10111100.10111100.00000100.00000000 网络标识不一样，即不在同一网段。 判断是不是在同一网段，你会了吧，下面，我们来点实际的。 一个公司有530台电脑，组成一个对等局域网，子网掩码和ip设多少最合适？ 子网掩码不说了，前面算出结果来了11111111.11111111.11111100.00000000，也就是255.255.252.0 我们现在要确定的是ip如何分配，首先，选一个b类ip段，这里就选188.188.x.x吧 这样，ip的前两段确定的，关键是要确定第三段，只要网络标识相同就可以了。我们先来确定网络号。（我们把子网掩码中的1和ip中的?对就起来，0和*对应起来，如下：）
255.255.252.0 11111111.11111111.11111100.00000000
188.188.x.x 10111100.10111100.??????**.********
网络标识 10111100.10111100.??????00.00000000 由此可知，?处随便填（只能用0和1填，不一定全是0和1），我们就用全填0吧，*处随便，这样呢，我们的ip就是 10111100.10111100.000000**.********，一共有530台电脑，ip的最后一段1～254可以分给254台计算机，530/254＝2.086，采用进1法，得整数3，这样，我们确定了ip的第三段要分成三个不同的数字，也就是说，把000000**中的**填三次数字，只能填1和0，而且每次的数字都不一样，至于填什么，就随我们便了，如00000001，00000010，00000011，转换成二进制，分别是1，2，3，这样，第三段也确定了，这样，就可以把ip分成188.188.1.y，188.188.2.y，188.188.3.y，y处随便填，只要在1～254范围之内，并且这530台电脑每台和每台的ip不一样，就可以了。
]]>
(1)快速定位,根据node.id
注： ext 树的节点如果不展开,数据是获取不到的( getnodebyid() 报异常)，即使你load了数据不展开节点前，一样获取不到。
var node=treepanel.getnodebyid(node_id);
// treepanel.expandpath(node.getpath())
treepanel.getselectionmodel().select(node)
node.fireevent('click',node)
(2)递归查找,一层一层级联查找
注: 虽然能解决(1)中取不到数据的问题,但访问速度慢,而且级联查找时会层层扩展开.
treepanel.getrootnode().cascade(function(n) {
注: 虽然能解决(1)中取不到数据的问题,但访问速度慢,而且级联查找时会层层扩展开.
treepanel.getrootnode().cascade(function(n) {
if (!n.isleaf() && !n.isloaded()) {
n.reload();
return true;
}
if (n.attributes['id'] == ext.getcmp('partid').getvalue()) {
node = n;
treepanel.getselectionmodel().select(node)
node.fireevent('click', node)
return false;
}
return true;
});
]]>
2.link方式添加插件
例:
在d:\program files\myeclipse 6.6\eclipse\links日录下,新建xxx.link文件.
内容为: path = d:/program files/myeclipse 6.6/myeclipse_plugins(自定义文件夹)/stp(插件名)
注:必须设置路径为:\\或/.
myeclipse 安装所有插件有两种方式，一种可以直接放到 安装路径下\eclipse\plugins中。但这种安装方式在重装 myeclipse时插件还得重新装。
另外一种是利用link文件链接安装：
1.将插件包解压，放到 放到某路径下 \eclipse\plugins 文件夹中（如果解压之后含有plugins文件夹则直接放到eclipse文件夹下，总之要保证含有\eclipse\plugins 形式的路径）。由于这某路径是用来存放所有插件的，所以推荐规范一些，比如我的d:\plugin\axis_plugin\eclipse\plugins（plugin表示这是插件文件夹，axis_plugin表示这是axis插件。axis那两个插件就放在\eclipse\plugins下。），如果有其他插件可在d:\plugin下依照规则建立其他文件夹。
2.在myeclipse 安装路径下的\eclipse\links文件夹文件夹中（如我的在d:\program files\myeclipse 6.5\eclipse\links），建立 xxx.link文件，如axis2_plugin.link。用记事本打开在里面编辑第一步的 “某路径”，在\eclipse之前，路径中要用“\\”（原因是\要进行符号转换，和程序中遇到的一样），如我的路径配置 path=d:\\plugin\\axis_plugin （这样程序就会自己找该路径下 \eclipse\plugins 中的插件）。
3删除 myeclipse 路径下\eclipse\configuration中的org.eclipse.update文件夹。
4启动myeclipse 选择“file->new->other”可以看到如下界面
表示插件添加成功。其他插件也可用类似的方法找到图标，比如svn插件可以在 工具栏window->show view ->other中找到图标。
祝你成功
二.myeclipse8.5
在myeclipse的dropins目录下新建一个svn.link(ps:这里什么文件名和后缀名都没关系),
里面内容是path=插件的路径，其他类似myeclipse7.5
]]>
包含了一个运算的规则：相等运算符判断时，
其中一个是true，先转换成1(false则转换为0)再做比较。
"" == false，现将false转化为0，即：判断"" == 0。
空串转换成数字0，0==0，所以
alert("" == false)显示的是true。
]]>
原码和反码，补码都是一样的，都是正数本身。
(2)负数
原码是符号位为1,数值部分取x绝对值的二进制。
反码是符号位为1,其它位是原码取反。
补码是符号位为1,其它位是原码取反，未位加1。也就是说，负数的补码是其反码未位加1。
正负0都为0 000.
(3) 移码
就是将符号位取反的补码.无论正数和负数,0除外,0的补码和移码相同.
也可以理解成:不算符号位外,最高数据位的进位.最高数据位为0,符号位为0;为1,符号位为1.
例:
原码 反码 补码 移码
0 0 000 0 000 0 000 1 000
-0 1 000 1 111 0 000 0 000
1011 原码：01011 反码：01011 //正数时，反码＝原码 补码：01011 //正数时，补码＝原码 移码：11011 //原数 10000 －1011 原码：11011 反码：10100 //负数时，反码为原码取反 补码：10101 //负数时，补码为原码取反＋1 移码：00101 //原数 10000 0．1101 原码：0.1101 反码：0.1101 //正数时，反码＝原码 补码：0.1101 //正数时，补码＝原码 移码：1.1101 //原数 1 －0．1101 原码：1.1101 反码：1.0010 //负数时，反码为原码取反 补码：1.0011 //负数时，补码为原码取反＋1 移码：0.0010 //原数 1
]]>
非格式化容量 = 位密度×内圆周长×每面磁道数×记录面数
格式化容量 = 扇区大小×每磁道扇区数×每面磁道数×记录面数
数据传输率 = 扇区大小×每磁道扇区数×转速
计算容量时,单位应统一.cm换成mm;mb换成kb; 位转换成字节=除以8.
(1)单记录面磁道数=磁道密度×(盘面外半径-盘面内半径)
(2)非格式化容量= 记录位密度×内圆周长×单记录面磁道数×记录面数
总磁道数= 单记录面磁道数×记录面数
内圆周长=3.14*内圆直径=2××半径 = 圆周率×直径
(3)格式化容量=记录面数×单记录面磁道数×每个磁道扇区数×扇区字节数
(4)一个磁道存储的字节数=磁盘扇区数×扇区字节
(5)数据传输率=每磁道扇区数×扇区大小×转速
(6)平均等待时间=磁盘转速时间的一半
平均存取时间是反应磁盘数据操作速度的指标，单位是毫秒（ms），他包括3个时间段：平均寻道时间，平均定位时间，转动延迟，其中后面两个统称为等待时间。
举例：
假设一个有3个盘片的硬盘，共有4个记录面，转速为7200/分钟，盘面有效记录区域的外直径为30cm，内直径为10cm，记录位密度为250位/mm，磁道密度为8道/mm，每个磁道分16扇区，每扇区512字节。
总磁道数：ct=磁盘面数*(外直径-内直径)/2*磁道密度=4*(30-10)*10/2*8=3200
非格式化容量：cuf=总磁道数*内径磁道周长*位密度=3200*(3.14*10*10)*(250/8)字节=29.95m
格式化容量：cf=总磁道数×每扇区数×每扇区字节数=4*=25m
平均数据传输速率：cg＝每磁道扇区数16×每扇区字节数512kb×转速(7200/60s)=983040=960kb/s
]]>
系统可靠性计算是软件设计师考试的一个重点，近些年几乎每次考试都会考到，但这个知识点的难度不高，了解基本的运算公式，即可轻松应对。
可靠性计算主要涉及三种系统，即串联系统、并联系统和冗余系统，其中串联系统和并联系统的可靠性计算都非常简单，只要了解其概念，公式很容易记住。冗余系统要复杂一些。在实际的考试当中，考得最多的就是串并混合系统的可靠性计算。所以要求我们对串联系统与并联系统的特点有基本的了解，对其计算公式能理解、运用。下面将对这些计算的原理及公式进行详细的说明。
串联系统
假设一个系统由n个子系统组成，当且仅当所有的子系统都能正常工作时，系统才能正常工作，这种系统称为串联系统，如图1所示。
设系统各个子系统的可靠性分别用r1，r2，……，rn表示，则系统的可靠性r=r1×r2×…×rn 。
如果系统的各个子系统的失效率分别用λ1，λ2，……，λn来表示，则系统的失效率λ=λ1×λ2×…×λn 。
并联系统
假如一个系统由n个子系统组成，只要有一个子系统能够正常工作，系统就能正常工作，如图2所示。
设系统各个子系统的可靠性分别用r1，r2，……，rn表示，则系统的可靠性r=1－（1－r1）×（1－r2）×…×（1－rn） 。
假如所有子系统的失效率均为λ，则系统的失效率为μ：
在并联系统中只有一个子系统是真正需要的，其余n-1个子系统都被称为冗余子系统。该系统随着冗余子系统数量的增加，其平均无故障时间也会增加。
串并混合系统
串并混合系统实际上就是对串联系统与并联系统的综合应用。我们在此以实例说明串并混合系统的可靠性如何计算。
例1：
某大型软件系统按功能可划分为2段p1和p2。为提高系统可靠性，软件应用单位设计了如下图给出的软件冗余容错结构，其中p1和p2均有一个与其完全相同的冗余备份。若p1的可靠度为0.9，p2的可靠度为0.9，则整个系统的可靠度是 。
供选择的答案a. 0.6561
b. 0.81
c. 0.9801
d. 0.9
试题分析
当系统采用串联方式时，其可靠度r可由公式r=r1r2…rn求得。当系统采用并联方式时，其可靠度r可由公式r=1-（1-r1）*(1-r2)…(1-rn)求得。这个系统总的来说是串联,但分成两个并联部分。第一部分的可靠度为：r1=1-(1-0.9)*(1-0.9)=0.99；第二部分的可靠度也为：r2=0.99；所以整个系统的可靠度为：r=r1*r2=0.9801 ，c答案。
试题答案
c
上面的例题是属于常规形式的可靠性计算题，如果把这种试题再拨高一个层次，可以。
例2：
1台服务器、3台客户机和2台打印机构成了一个局域网（如图4所示）。在该系统中，服务器根据某台客户机的请求，数据在一台打印机上输出。设服务器、各客户机及各打印机的可靠度分别为a、b、c，则该系统的可靠度为 。
a．ab3c3
b．a(1-b3)(1-c2)
c．a(1-b)3(l-c)2
d．a(1-(1-b)3)(1-(l-c)2)
例题分析
在试题给出的系统中，客户机之间是并联的（任何一台客户机出现故障，对其他客户机没有影响），同理，打印机之间是也并联关系。然后，客户机、服务器、打印机之间再组成一个串联关系。因此，我们可以把该系统简化为：
已知服务器、各客户机及各打印机的可用性分别为a、b、c，因此整个系统的可用性为：r=（1-（1-b）3）a（1-（1-c）2）=a（1-（1-b）3）（1-（1-c）2）
例题答案d
4．模冗余系统
m模冗余系统由m个（m=2n 1为奇数）相同的子系统和一个表决器组成，经过表决器表决后，m个子系统中占多数相同结果的输出可作为系统的输出，如图5所示。
在m个子系统中，只有n 1个或n 1个以上的子系统能正常工作，系统就能正常工作并输出正确结果。假设表决器是完全可靠的，每个子系统的可靠性为r0，则m模冗余系统的可靠性为：
]]>
具体描述：
表格第一列（其它列也行）为类型选择列，采用combobox为编辑器，当选择某一类型（如：类型1）时表格当前行的某些列（如：第2列~第4列）就变为不可编辑状态，并显示不同的样式（类似于button的disable）。
当选择其它类型（如：类型2）时表格当前行的不可编辑单元格又变成可编辑的。
(1)
是否可编辑样式可以在列模型的renderer中操作
renderer : function(data, meta){
if(xxx){
meta.css = " x-item-disabled";
}
}
(2)
是否可编辑逻辑可以在grid的beforeedit事件中拦截判断
grid.on("beforeedit", function(e){
/*
e = {
grid: this,
record: r,
field: field,
value: r.data[field],
row: row,
column: col,
cancel:false
};
*/
if(xxx){
return false; // 中止，不让编辑
}
});
]]>
]]>
输出：
george.john.thomas
]]>
]]>
{
if(array == null)
return null;
if(separator == null)
separator = "";
int arraysize = array.length;
int bufsize = arraysize != 0 ? arraysize * ((array[0] != null ? array[0].tostring().length() : 16) (separator == null ? 0 : separator.length())) : 0;
stringbuffer buf = new stringbuffer(bufsize);
for(int i = 0; i < arraysize; i )
{
if(separator != null && i > 0)
buf.append(separator);
if(array[i] != null)
buf.append(array[i]);
}
return buf.tostring();
}
]]>
hibernate annotation几种关联映射
一对一(one-to-one)
使用@onetoone注解建立实体bean之间的一对一关联。一对一关联有三种情况：(1).关联的实体都共享同样的主键，(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束)，(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。
1.共享主键的一对一关联映射：
@entity
@table(name="test_body")
public class body {
private integer id;
private heart heart;
@id
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
@onetoone
@primarykeyjoincolumn
public heart getheart() {
return heart;
}
public void setheart(heart heart) {
this.heart = heart;
}
}
@entity
@table(name="test_heart")
public class heart {
private integer id;
@id
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
}
通过@primarykeyjoincolumn批注定义了一对一关联
2.使用外键进行实体一对一关联：
@entity
@table(name="test_trousers")
public class trousers {
@id
public integer id;
@onetoone
@joincolumn(name = "zip_id")
public trouserszip zip;
}
@entity
@table(name="test_trouserszip")
public class trouserszip {
@id
public integer id;
@onetoone(mappedby = "zip")
public trousers trousers;
}
上面的例子是指trousers通过trousers的外键列zip_id和trouserszip关联，@joincolumn批注定义了联接列，该批注和@column批注有点类似，但是多了一个名为referencedcolumnname的参数。该参数定义了所关联目标实体中的联接列，注意，当referencedcolumnname关联到非主键列的时候，关联的目标类必须实现serializable，还要注意的是所映像的属性对应单个列（否则映射无效）
一对一关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedny属性进行声明。mappedby的值指向主体的关联属性。例子中，mappedby的值为zip。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。
如果在主体没有声明@joincolumn，系统自动进行处理：在主表（owner table）中将创建联接列，列名为：主体的关联属性名 下划线 被关联端的主键列名。上面的例子中是zip_id,因为trousers中的关联属性名为zip，trouserszip的主键是id。
3.通过关联表定义一对一关联
@entity
@table(name="test_people")
public class people {
@id
public integer id;
@onetoone
@jointable(name ="testpeoplepassports",
joincolumns =@joincolumn(name="people_fk"),
inversejoincolumns =@joincolumn(name="passport_fk")
)
public passport passport;
}
@entity
@table(name="test_passport")
public class passport {
@id
public integer id;
@onetoone(mappedby = "passport")
public people people;
}
people通过名为testpeoplepassports的关联表和passport关联。该关联表拥有名为passport_fk的外键列，该外键指向passport表，该信息定义为inversejoincoloumns的属性值，而people_fk外键列指向people表，该信息定义为joincolumns的属性值。
这种关联可能是双向的，在双向关联中，有且仅有一端作为主体（owner）端存在：主体端负责维护联接列（即更新），对于不需要维护这种关系的从表则通过mappedny属性进行声明。mappedby的值指向主体的关联属性。例子中，mappedby的值为passport。最后，不必也不能再在被关联端（ownedside）定义联接列了，因为已经在主体端声明了。
以上是一对一关联的三种形式，下面介绍多对一关联。
多对一(many-to-one)
使用@manytoone批注来实现多对一关联。
@manytoone批注有一个名为targetentity的参数，该参数定义了目标实体名，通常不需要定义该参数，因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足需求了。不过下面这种情况下这个参数就显得有意义了：使用接口作为返回值而不是常见的实体。
@manytoone(targetentity=companyimpl.class)
@joincoloumn(name=”copm_id”)
public company getcompany(){
return company;
}
多对一的配置方式有两种：(1)通过@joincoloumn映像(2)通过关联表的方式来映像
(1) 通过@joincoloumn映射
srd framework中company,category例子：
company：
@manytoone
@joincolumn(name = "category_option_id")
private category category = null;
category：
@discriminatorvalue("category")
public class category extends option {
}
(2) 通过关联表映射
通过@jointable批注定义关联表，该关联表包含了指回实体表的外键(通过@jointable.joincoloumns)以及指向目标实体表的外键(通过@jointable.inversejoincoloumns)
@entity
@table(name="test_treetype")
public class treetype {
private integer id;
private string name;
private foresttype foresttype;
@manytoone(fetch = fetchtype.lazy)
@jointable(name="test_tree_forest",
joincolumns = @joincolumn(name="tree_id"),
inversejoincolumns = @joincolumn(name="forest_id") )
public foresttype getforesttype() {// foresttype的getter，setter方法必须在这里，否则会出错
return foresttype;
}
public void setforesttype(foresttype foresttype) {
this.foresttype = foresttype;
}
@id
@generatedvalue
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
}
@entity
@table(name="test_foresttype")
public class foresttype {
private integer id;
private string name;
private set trees;
@onetomany(mappedby="foresttype")
public set gettrees() {// trees的getter，setter方法必须在这里，否则会出错
return trees;
}
public void settrees(set trees) {
this.trees = trees;
}
@id @generatedvalue
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
}
一对多(one-to-many)
使用@onetomany批注可定义一对多关联，一对多关联可以是双向关联。
在ejb3规范中多对一这端几乎总是双向关联中的主体(owner)端，而一对多这端关联批注为@onetomany(mappedby...)
@entity
public class troop{
@onetomany(mappedby=”troop”)
public set getsoldiers(){
......
}
@entity
public class soldier{
@manytoone
@joincolumn(name=”troop_fk”)
public troop gettroop(){
......
}
troop通过troop属性和soldier建立一对多的双向关联，在mappedby端不必也不能再定义任何物理映射。
对于一对多的双向映射，如果要一对多这一端维护关联关系，你需要删除mappedby元素并将多对一这端的@joincoloumn的insertable和updatabel设置为false。这种方案不会得到什么明显的优化，而且还会增加一些附加的update语句。
单向：
通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的，也是不推荐的，建议通过一个联接表来实现这种关联(下面会讲到)。
@joincoloumn批注来描述这种单向关联关系
@entity
public class customer{
@onetomany
@joincoloumn(name=”cust_id”)
public set gettickets() {
......
}
@entity
public class ticket{
...
}
customer通过cust_id列和ticket建立了单向关联关系
通过关联表处理单向关联：
通过联接表处理单向一对多关联是首选方式，这种关联通过@jointable批注进行描述
@entity
public class trainer{
@onetomany
@jointable(
name = "trainedmonkeys",
joncolumns = {@joincolumn(name = "trainer_id")},
inversejoincolumns = @joincolumn(name = "monkey_id")
)
public set gettrainedmonkeys() {
return trainedmonkeys;
}
......
}
@entity
public class monkey {
...//no bidir
}
上面这个例子中，trainer通过trainedmonkeys表和monkey建立了单向关联，其中外键trainer_id关联到trainer(joincoloumn),而外键monkey_id关联到monkey(inversejioncoloumns)
默认处理机制：
通过联接表来建立单向一对多关联不需要描述任何物理映像，表名由以下三个部分组成：主表(ownertable)表名 从表(the other side table)表名，指向主表的外键名：主表表名 下划线 主表主键列名，指向从表的外键名：主表所对应实体的属性名 下划线 从表主键列名，指向从表的外键定义为唯一约束，用来表示一对多的关联关系。
@entity
public class trainer{
@onetomany
public set gettrainedtigers(){
... ...
}
@entity
public class tiger{
.. ..//no bidir
}
上面这个例子中，trainer和tiger通过联接表trainer_tiger建立单向关联关系，其中外键trainer_id关联到trainer,而外键trainedtigers_id关联到tiger
多对多(many-to-many)
使用@manytomany批注可定义多对多关联，同时，你也许要通过批注@jointable描述关联表和关联条件。如果是双向关联，其中一段必须定义为owner，另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略)
@entity()
public class employer implements serializable {
private integer id;
private collection employees;
@manytomany(
targetentity = org.hibernate.test.annotations.manytomany.employee.class,
cascade = {cascadetype.persist, cascadetype.merge}
)
@jointable(
name = "employer_employee",
joincolumns = {@joincolumn(name = "emper_id")},
inversejoincolumns = {@joincolumn(name = "empee_id")}
)
public collection getemployees() {
return employees;
}
...
}
@entity()
public class employee implements serializable {
@manytomany(
cascade = {cascadetype.persist, cascadetype.merge},
mappedby = "employees"
targetentity = employer.class
)
public collection getemployers() {
return employers;
}
.. ..
}
@jointable批注定义了联接表的表名，联接列数组，以及invers联接列数组，后者是关联表中关联到employee主键的列(the “other side”)。
被关联端不必也不能描述物理映射：只需要一个简单的mappedby参数，该参数包含了主体端的属性名，这样就绑定了双方的关系。
默认值：
和其它许多批注一样，在多对多关联中很多值是自动生成，党双向多对多关联中没有定义任何物理映射时，hibernate根据以下规则生成相应的值，关联表名：主表表名 下划线 从表表名，关联到主表的外键名：主表名 下划线 主表中的主键列名，关联到从表的外键名：主表中用于关联的属性名 下划线 从表的主键列名，以上规则对于双向一对多关联同样一样。
以上是整理的一点简单的几种映射，可参考ejb3.pdf中p111——p131，hibernate_annotation.pdf 第二章
在这里没有具体的例子，有很多内容还需要仔细查看文档。
]]>
语法就是
with tempname as (select ....)
select ...
例子：
with t as (select * from emp where depno=10)
select * from t where empno=xxx
with
wd as (select did,arg(salary) 平均工资 from work group by did),
em as (select emp.*,w.salary from emp left join work w on emp.eid = w.eid)
select * from wd,em where wd.did =em.did and wd.平均工资>em.salary;
2、何时被清除
临时表不都是会话结束就自动被pga清除嘛! 但with as临时表是查询完成后就被清除了！
23:48:58 scott@orcl> with aa as(select * from dept)
23:57:58 2 select * from aa;
deptno dname loc
---------- -------------- -------------
10 accounting new york
20 research dallas
30 sales chicago
40 operations boston
已用时间: 00: 00: 00.12
23:58:06 scott@orcl> select * from aa;
select * from aa
*
第 1 行出现错误:
ora-00942: 表或视图不存在
已用时间: 00: 00: 00.02
23:58:14 scott@orcl>
3、就这一功能来说，子查询就可以达到啊，为什么要用with呢？ 用with有什么好处？
都能写，但执行计划不同的。当有多个相似子查询的时候，用with写公共部分，因为子查询结果在内存临时表中，执行效率当然就高啦~
4、问题：
有张表数据如下：
aaa 高
bbb 低
aaa 低
aaa 高
bbb 低
bbb 高
需要得到下列结果,
高 低
aaa 2 1
bbb 1 2
问 sql 语句怎么写？？
答案：
with tt as (
select 'aaa' id, '高' value from dual union all
select 'bbb' id, '低' value from dual union all
select 'aaa' id, '低' value from dual union all
select 'aaa' id, '高' value from dual union all
select 'bbb' id, '低' value from dual union all
select 'bbb' id, '高' value from dual)
select id,
count(decode(value, '高', 1)) 高,
count(decode(value, '低', 1)) 低
from tt
group by id;
===================================================================
扩展：
oracle9i新增with语法，可以将查询中的子查询命名，放到select语句的最前面。
一个简单的例子:
sql> with
2 seg as (select segment_name, sum(bytes)/1024 k from user_segments group by segment_name),
3 obj as (select object_name, object_type from user_objects)
4 select o.object_name, object_type, nvl(s.k, 0) size_k
5 from obj o, seg s
6 where o.object_name = s.segment_name ( )
7 ;
object_name object_type size_k
------------------------------ ------------------- ----------
daijc_test table 128
p_test procedure 0
ind_daijc_test_c1 index 128
通过with语句定义了两个子查询seg和obj，在随后的select语句中可以直接对预定义的子查询进行查询。从上面的例子也可以看出，使用with语句，将一个包含聚集、外连接等操作sql清晰的展现出来。
with定义的子查询不仅可以使查询语句更加简单、清晰，而且with定义的子查询还具有在select语句的任意层均可见的特点。
即使是在with的定义层中，后定义的子查询都可以使用前面已经定义好的子查询:
sql> with
2 q1 as (select 3 5 s from dual),
3 q2 as (select 3 * 5 m from dual),
4 q3 as (select s, m, s m, s * m from q1, q2)
5 select * from q3;
s m s m s*m
---------- ---------- ---------- ----------
8 15 23 120
利用with定义查询中出现多次的子查询还能带来性能提示。oracle会对with进行性能优化，当需要多次访问with定义的子查询时，oracle会将子查询的结果放到一个临时表中，避免同样的子查询多次执行，从而有效的减少了查询的io数量。
with能用在select语句中，update和delete语句也是支持with语法的，只是需要版本支持:
http://www.oracle.com.cn/viewthread.php?tid=83530
=============================================================================
with
sql1 as (select to_char(a) s_name from test_tempa),
sql2 as (select to_char(b) s_name from test_tempb where not exists (select s_name from sql1 where rownum=1))
select * from sql1
union all
select * from sql2
union all
select 'no records' from dual
where not exists (select s_name from sql1 where rownum=1)
and not exists (select s_name from sql2 where rownum=1);
再举个简单的例子
with a as (select * from test)
select * from a;
其实就是把一大堆重复用到的sql语句放在with as 里面，取一个别名，后面的查询就可以用它
这样对于大批量的sql语句起到一个优化的作用，而且清楚明了
这是搜索到的英文文档资料(说得比较全,但是本人英文特菜,还没具体了解到,希望各高手具体谈谈这个with
as 的好处)
about oracle with clause
starting in oracle9i release 2 we see an incorporation of the sql-99 “with clause”, a tool for materializing subqueries to save oracle from having to re-compute them multiple times.
the sql “with clause” is very similar to the use of global temporary tables (gtt), a technique that is often used to improve query speed for complex subqueries. here are some important notes about the oracle “with clause”:
? the sql “with clause” only works on oracle 9i release 2 and beyond.
? formally, the “with clause” is called subquery factoring
? the sql “with clause” is used when a subquery is executed multiple times
? also useful for recursive queries (sql-99, but not oracle sql)
to keep it simple, the following example only references the aggregations once, where the sql “with clause” is normally used when an aggregation is referenced multiple times in a query.
we can also use the sql-99 “with clause” instead of temporary tables. the oracle sql “with clause” will compute the aggregation once, give it a name, and allow us to reference it (maybe multiple times), later in the query.
the sql-99 “with clause” is very confusing at first because the sql statement does not begin with the word select. instead, we use the “with clause” to start our sql query, defining the aggregations, which can then be named in the main query as if they were “real” tables:
with
subquery_name
as
(the aggregation sql statement)
select
(query naming subquery_name);
retuning to our oversimplified example, let’s replace the temporary tables with the sql “with clause”:
with
sum_sales as
select /* materialize */
sum(quantity) all_sales from stores
number_stores as
select /* materialize */
count(*) nbr_stores from stores
sales_by_store as
select /* materialize */
store_name, sum(quantity) store_sales from
store natural join sales
select
store_name
from
store,
sum_sales,
number_stores,
sales_by_store
where
store_sales > (all_sales / nbr_stores)
;
note the use of the oracle undocumented “materialize” hint in the “with clause”. the oracle materialize hint is used to ensure that the oracle cost-based optimizer materializes the temporary tables that are created inside the “with” clause. this is not necessary in oracle10g, but it helps ensure that the tables are only created one time.
it should be noted that the “with clause” does not yet fully-functional within oracle sql and it does not yet support the use of “with clause” replacement for “connect by” when performing recursive queries.
to see how the “with clause” is used in ansi sql-99 syntax, here is an excerpt from jonathan gennick’s great work “understanding the with clause” showing the use of the sql-99 “with clause” to traverse a recursive bill-of-materials hierarchy
the sql-99 “with clause” is very confusing at first because the sql statement does not begin with the word select. instead, we use the “with clause” to start our sql query, defining the aggregations, which can then be named in the main query as if they were “real” tables:
with
subquery_name
as
(the aggregation sql statement)
select
(query naming subquery_name);
retuning to our oversimplified example, let’s replace the temporary tables with the sql “with” clause”:
]]>
oracle 数据库:
hibernate annotation :
caused by: org.hibernate.hibernateexception: wrong column type: numbers, expected: number(20,3) default 0
hibernate annotation :
@column(name="numbers",columndefinition="number(20,3) default 0 ")
public bigdecimal getnumbers() {
return numbers;
}
异常:
异常:
at org.hibernate.mapping.table.validatecolumns(table.java:261)
at org.hibernate.cfg.configuration.validateschema(configuration.java:1083)
at org.hibernate.tool.hbm2ddl.schemavalidator.validate(schemavalidator.java:116)
at org.hibernate.impl.sessionfactoryimpl.(sessionfactoryimpl.java:317)
at org.hibernate.cfg.configuration.buildsessionfactory(configuration.java:1294)
at org.hibernate.cfg.annotationconfiguration.buildsessionfactory(annotationconfiguration.java:915)
at org.hibernate.ejb.ejb3configuration.buildentitymanagerfactory(ejb3configuration.java:730)
... 122 more
解决方法:
解决方法:
@column(name="numbers",columndefinition="number(20,3) default 0 ")
public bigdecimal getnumbers() {
return numbers;
}
原因:hibernate 在列定义选项中,数据库中的所有类型应为小写number. hibernate在此直接面对数据库,所以区分大小写.
原因:hibernate 在列定义选项中,数据库中的所有类型应为小写number. hibernate在此直接面对数据库,所以区分大小写.
]]>
oracle的分析函数over 及开窗函数
一：分析函数over
oracle从8.1.6开始提供分析函数，分析函数用于计算基于组的某种聚合值，它和聚合函数的不同之处是
对于每个组返回多行，而聚合函数对于每个组只返回一行。
下面通过几个例子来说明其应用。
oracle从8.1.6开始提供分析函数，分析函数用于计算基于组的某种聚合值，它和聚合函数的不同之处是
对于每个组返回多行，而聚合函数对于每个组只返回一行。
下面通过几个例子来说明其应用。
1：统计某商店的营业额。
date sale
1 20
2 15
3 14
4 18
5 30
规则：按天统计：每天都统计前面几天的总额
得到的结果：
date sale sum
----- -------- ------
1 20 20 --1天
2 15 35 --1天＋2天
3 14 49 --1天＋2天＋3天
4 18 67 .
5 30 97 .
2:统计各班成绩第一名的同学信息
1 20
2 15
3 14
4 18
5 30
规则：按天统计：每天都统计前面几天的总额
得到的结果：
date sale sum
----- -------- ------
1 20 20 --1天
2 15 35 --1天＋2天
3 14 49 --1天＋2天＋3天
4 18 67 .
5 30 97 .
2:统计各班成绩第一名的同学信息
name class s
----- ----- ----------------------
fda 1 80
ffd 1 78
dss 1 95
cfe 2 74
gds 2 92
gf 3 99
ddd 3 99
adf 3 45
asdf 3 55
3dd 3 78
通过：
--
select * from
(
select name,class,s,rank()over(partition by class order by s desc) mm from t2
)
where mm=1
--
得到结果：
name class s mm
----- ----- ---------------------- ----------------------
dss 1 95 1
gds 2 92 1
gf 3 99 1
ddd 3 99 1
注意：
1.在求第一名成绩的时候，不能用row_number()，因为如果同班有两个并列第一，row_number()只返回一个结果
2.rank()和dense_rank()的区别是：
--rank()是跳跃排序，有两个第二名时接下来就是第四名
--dense_rank()l是连续排序，有两个第二名时仍然跟着第三名
3.分类统计 (并显示信息)
----- ----- ----------------------
fda 1 80
ffd 1 78
dss 1 95
cfe 2 74
gds 2 92
gf 3 99
ddd 3 99
adf 3 45
asdf 3 55
3dd 3 78
通过：
--
select * from
(
select name,class,s,rank()over(partition by class order by s desc) mm from t2
)
where mm=1
--
得到结果：
name class s mm
----- ----- ---------------------- ----------------------
dss 1 95 1
gds 2 92 1
gf 3 99 1
ddd 3 99 1
注意：
1.在求第一名成绩的时候，不能用row_number()，因为如果同班有两个并列第一，row_number()只返回一个结果
2.rank()和dense_rank()的区别是：
--rank()是跳跃排序，有两个第二名时接下来就是第四名
--dense_rank()l是连续排序，有两个第二名时仍然跟着第三名
3.分类统计 (并显示信息)
a b c
-- -- ----------------------
m a 2
n a 3
m a 2
n b 2
n b 1
x b 3
x b 2
x b 4
h b 3
-- -- ----------------------
m a 2
n a 3
m a 2
n b 2
n b 1
x b 3
x b 2
x b 4
h b 3
select a,c,sum(c)over(partition by a) from t2
得到结果：
a b c sum(c)over(partitionbya)
-- -- ------- ------------------------
h b 3 3
m a 2 4
m a 2 4
n a 3 6
n b 2 6
n b 1 6
x b 3 9
x b 2 9
x b 4 9
如果用sum，group by 则只能得到
a sum(c)
-- ----------------------
h 3
m 4
n 6
x 9
无法得到b列值
＝＝＝＝＝
得到结果：
a b c sum(c)over(partitionbya)
-- -- ------- ------------------------
h b 3 3
m a 2 4
m a 2 4
n a 3 6
n b 2 6
n b 1 6
x b 3 9
x b 2 9
x b 4 9
如果用sum，group by 则只能得到
a sum(c)
-- ----------------------
h 3
m 4
n 6
x 9
无法得到b列值
＝＝＝＝＝
select * from test
数据:
a b c
1 1 1
1 2 2
1 3 3
2 2 5
3 4 6
---将b栏位值相同的对应的c 栏位值加总
select a,b,c, sum(c) over (partition by b) c_sum
from test
a b c c_sum
1 1 1 1
1 2 2 7
2 2 5 7
1 3 3 3
3 4 6 6
---如果不需要已某个栏位的值分割,那就要用 null
eg: 就是将c的栏位值summary 放在每行后面
select a,b,c, sum(c) over (partition by null) c_sum
from test
a b c c_sum
1 1 1 17
1 2 2 17
1 3 3 17
2 2 5 17
3 4 6 17
求个人工资占部门工资的百分比
sql> select * from salary;
name dept sal
---------- ---- -----
a 10 2000
b 10 3000
c 10 5000
d 20 4000
sql> select name,dept,sal,sal*100/sum(sal) over(partition by dept) percent from salary;
name dept sal percent
---------- ---- ----- ----------
a 10 2000 20
b 10 3000 30
c 10 5000 50
d 20 4000 100
二：开窗函数
开窗函数指定了分析函数工作的数据窗口大小，这个数据窗口大小可能会随着行的变化而变化，举例如下：
1：
over（order by salary） 按照salary排序进行累计，order by是个默认的开窗函数
over（partition by deptno）按照部门分区
2：
over（order by salary range between 5 preceding and 5 following）
每行对应的数据窗口是之前行幅度值不超过5，之后行幅度值不超过5
例如:对于以下列
aa
1
2
2
2
3
4
5
6
7
9
sum(aa)over（order by aa range between 2 preceding and 2 following）
得出的结果是
aa sum
---------------------- -------------------------------------------------------
1 10
2 14
2 14
2 14
3 18
4 18
5 22
6 18
7 22
9 9
就是说，对于aa=5的一行 ，sum为 5-1<=aa<=5 2 的和
对于aa=2来说 ，sum=1 2 2 2 3 4=14 ；
又如 对于aa=9 ，9-1<=aa<=9 2 只有9一个数，所以sum=9 ；
3：其它：
over（order by salary rows between 2 preceding and 4 following）
每行对应的数据窗口是之前2行，之后4行
4：下面三条语句等效：
over（order by salary rows between unbounded preceding and unbounded following）
每行对应的数据窗口是从第一行到最后一行，等效：
over（order by salary range between unbounded preceding and unbounded following）
等效
over(partition by null)
开窗函数指定了分析函数工作的数据窗口大小，这个数据窗口大小可能会随着行的变化而变化，举例如下：
1：
over（order by salary） 按照salary排序进行累计，order by是个默认的开窗函数
over（partition by deptno）按照部门分区
2：
over（order by salary range between 5 preceding and 5 following）
每行对应的数据窗口是之前行幅度值不超过5，之后行幅度值不超过5
例如:对于以下列
aa
1
2
2
2
3
4
5
6
7
9
sum(aa)over（order by aa range between 2 preceding and 2 following）
得出的结果是
aa sum
---------------------- -------------------------------------------------------
1 10
2 14
2 14
2 14
3 18
4 18
5 22
6 18
7 22
9 9
就是说，对于aa=5的一行 ，sum为 5-1<=aa<=5 2 的和
对于aa=2来说 ，sum=1 2 2 2 3 4=14 ；
又如 对于aa=9 ，9-1<=aa<=9 2 只有9一个数，所以sum=9 ；
3：其它：
over（order by salary rows between 2 preceding and 4 following）
每行对应的数据窗口是之前2行，之后4行
4：下面三条语句等效：
over（order by salary rows between unbounded preceding and unbounded following）
每行对应的数据窗口是从第一行到最后一行，等效：
over（order by salary range between unbounded preceding and unbounded following）
等效
over(partition by null)
]]>
■另存为■
■属性■
■打印■
■打印预览■
■页面设置■
■刷新■
■导入收藏■
■导出收藏■
■加入收藏■
■整理收藏夹■
■查看原文件■
■语言设置■
■前进■
■后退■
]]>
webbrowser组件的execwb方法
1.
2. 调用方法:
webbrowser.execwb ncmdid, ncmdexecopt, [pvain], [pvaout]
3. 参数说明:
(a).ncmdid
olecmdid_open = 1,
olecmdid_new = 2,
olecmdid_save = 3,
olecmdid_saveas = 4,
olecmdid_savecopyas = 5,
olecmdid_print = 6,
olecmdid_printpreview = 7,
olecmdid_pagesetup = 8,
olecmdid_spell = 9,
olecmdid_properties = 10,
olecmdid_cut = 11,
olecmdid_copy = 12,
olecmdid_paste = 13,
olecmdid_pastespecial = 14,
olecmdid_undo = 15,
olecmdid_redo = 16,
olecmdid_selectall = 17,
olecmdid_clearselection = 18,
olecmdid_zoom = 19,
olecmdid_getzoomrange = 20
olecmdid_updatecommands = 21
olecmdid_refresh = 22
olecmdid_stop = 23
olecmdid_hidetoolbars = 24
olecmdid_setprogressmax = 25
olecmdid_setprogresspos = 26
olecmdid_setprogresstext = 27
olecmdid_settitle = 28
olecmdid_setdownloadstate = 29
olecmdid_stopdownload = 30
上面的关键词都可以在浏览器的菜单里面找到对应的选项﹐大家一看就明白的﹗
(b).ncmdexecopt
olecmdexecopt_dodefault = 0,
olecmdexecopt_promptuser = 1,
lecmdexecopt_dontpromptuser = 2,
olecmdexecopt_showhelp = 3
对于这个参数﹐一般来说﹐选1就可以了。
4.常用:
webbrowser.execwb(1,1) 打开
webbrowser.execwb(2,1) 关闭现在所有的ie窗口，并打开一个新窗口
webbrowser.execwb(4,1) 保存网页
webbrowser.execwb(6,1) 打印
webbrowser.execwb(7,1) 打印预览
webbrowser.execwb(8,1) 打印页面设置
webbrowser.execwb(10,1) 查看页面属性
webbrowser.execwb(15,1) 好像是撤销，有待确认
webbrowser.execwb(17,1) 全选
webbrowser.execwb(22,1) 刷新
webbrowser.execwb(45,1) 关闭窗体无提示
5.示例﹕
(a)调用ie的”另存为”功能的示例﹕
(b)经过改写的登陆模式
]]>
dao.gethibernatesession().createquery(hql).setparameter("bookid", bookid).setparameter("batch", batch).executeupdate();
(1)string hql="delete from tbproduceplanaccount ppa where ppa.tbbusinessplanaccount.batch=:batch and ppa.tbproduceplanbook.id=:bookid ";
异常:
总结: hibernate的理解方式与人不同,不能自动生成子查询;更新或删除操作是不允许联表的,必须通过子查询找出数据.
题外语:级联删除是要设置映射的.
(1)string hql="delete from tbproduceplanaccount ppa where ppa.tbbusinessplanaccount.batch=:batch and ppa.tbproduceplanbook.id=:bookid ";
异常:
hibernate: delete from tb_produceplanaccount, tb_businessplanaccount tbbusiness1_ where batch=? and produceplanbook_id=?
2011-11-17 11:50:16,166 warn [jdbcexceptionreporter] sql error: 933, sqlstate: 42000
2011-11-17 11:50:16,166 error [jdbcexceptionreporter] ora-00933: sql 命令未正确结束
(2)hql="delete from tbproduceplanaccount ppa where ppa in (from tbproduceplanaccount ppa where ppa.tbbusinessplanaccount.batch=:batch and ppa.tbproduceplanbook.id=:bookid)";
2011-11-17 11:50:16,166 warn [jdbcexceptionreporter] sql error: 933, sqlstate: 42000
2011-11-17 11:50:16,166 error [jdbcexceptionreporter] ora-00933: sql 命令未正确结束
(2)hql="delete from tbproduceplanaccount ppa where ppa in (from tbproduceplanaccount ppa where ppa.tbbusinessplanaccount.batch=:batch and ppa.tbproduceplanbook.id=:bookid)";
执行正常.
总结: hibernate的理解方式与人不同,不能自动生成子查询;更新或删除操作是不允许联表的,必须通过子查询找出数据.
题外语:级联删除是要设置映射的.
]]>
注:登入sqlplus时报错,如下:
请输入用户名: system
请输入用户名: system
输入口令:
error:
ora-12560: tns: 协议适配器错误
原因:是orcal实例没启动(net [start/stop] 服务名).与linux相反,不在sqlplus中启动实例.
原因:是orcal实例没启动(net [start/stop] 服务名).与linux相反,不在sqlplus中启动实例.
平台: windows server 2003 enterprise editon , oracle 10g(10.02.00.01)
- 运行"开始->程序\oracle - oradb10g_home1\配置和移植工具"中的"database configuration assistant"，创建一个数据库。
- 创建成功后，运行"开始->程序\oracle - oradb10g_home1\应用程序开发"中的"sql plus".用户名：sys 密码：123456 as sysdba(密码后面要加空格as空格sysdba) 主机字符串：如果是本机可不填。
-
从命令提示符下使用sql*plus
sqlplus/nolog
conn 用户名/密码 as sysdba 出现”已连接“后就是成功了。
接下来，我们在sql*plus中实战一下，为我们下面将要做的打好基础。
用system登陆到sql*plus后，我们做如下操作(这次没有截图，有详细的说明)
-----------如登陆成功此1-3步不必做，直接做第4步----------------
- sql>create user maxuan identified by max; #创建口令为max的用户maxuan
- sql>grant connect,resource to maxuan; #为用户maxuan授权
- sql>conn maxuan/max; #以用户maxuan进行连接
- sql>create table test(a number); #建立一个名为test的表，只有字段名为a的一列，数据类型为数字
- sql>insert into test values(1); #插入一条记录
- sql>select * from test; #查询记录，此时a列的第一行为1
- sql>update test set a=2; #更改记录，此时a列的第一行已改为2
- sql>commit; #提交.在完成数据库的插入，删除和修改操作时，只有当事务提交到数据库才算完成。
- sql>delete from test; #删除test表中所有的记录，此时test表中没有记录
- sql>roll; #回滚到提交前，此时再查询test表，a列第一行值又回复到2
oracle的数据类型
在数据库中创建数据表的时候，我们需要定义表中所有字段的类型，数据类型大致分为：character,numberic,date,lob和raw等，这些是最基本的数据类型。当然在oracle中也允许自定义数据类型！
在oracle中提供的character数据类型:
char():固定长度字符串，最大长度为2000字节，如果不指定长充，缺省为1个字节长。
varchar2():可变长度的字符串，最大长度为4000字节，具体定义时指明最大长度，这咱类型可以放数字、字母以及ascii码字符集(或者ebcdic等数据库系统接受的字符集标准)中的所有符号。如果数据长度没有达到最大值，oracle会根据数据大小自动调节字段长度。是
最长用的数据类型。
nchar():根据字符集而定的固定长度字符串，最大长度2000字节。
nvarchar2():根据字符集而定的可变长度字符串，最大长度4000字节。
long:可变长字符列，最大长度限制为2gb，用于不需要作字符串搜索的长串数据。此类型是一个遗留下来的而且将来不会被支持的数据类型，逐渐被blob，clob，nclob等大的数据类型所取代。
numberic数据类型用来存储负的和正的整数，分数和浮点型数据，在oracle中提供的numberic数据类型：
number(,):可变长的数值列，允许0、正值及负值，m是所有的有效数字的位数，n是小数点以后的位数。
在oracle中提供的date数据类型:
date:缺省格式是dd-mon-yy(日-月-年)
在oracle中提供的lob数据类型:
blob、clob、nclob：三种大型对象(lob)，用来保存较大的图形文件或带格式的文本文件，如word文档，以及音频、视频等非文本文件，最大长充是4gb。晕些数据存储在数据库内部保存。
bfile:在数据库外部保存的大型二进制对象文件，最大长度是4gb，这种外部的lob类型，通过数据库记录变化情况，但是数据的具体保存是在数据库外部进行的。
在oracle中提供的raw数据类型:
raw():可变长二进制数据，具体定义字段时必须指明最大长度，这种格式用来保存较小的图形文件或带格式的文本文件，它也是一种较老的数据类型，将被lob数据类型所取代。
long raw:可变长二进制数据，最大长度是2gb，可以用来保存较大的图形或带格式的文本文件，以及音频、视频等非文本文件，这也是一种较老的数据类型，将被lob数据类型所取代。
其它的数据类型：
rowid:这是oracle数据表中的一个伪例，它是数据表中每行数据内在的唯一标识
integer:整数类型
补充知识：
sql(structure query language)语言是结构化查询语言，是数据库的核心语言，是面向集合的描述性非过程化语言。sql语言共分为四大类：数据查询语言dql,数据操纵语言dml，数据定义语言ddl,数据库控制语言dcl。
1.数据查询语言dql的基本结构是由select子句，from子句，where子句组成的查询块：
select <字段名表> from <表或视图名> where <查询条件>
2.数据操纵语言dml完成在数据库中确定、修改、添加、删除某一数据值的任务(以下是部分常用dml语句):
insert 增加数据行到表
delete 从表中删除数据行
update 更改表中数据
3.数据定义语言ddl完成定义数据库的结构，包括数据库本身、数据表、目录、视图等数据库元素(以下是部分常用ddl语句)
create table 创建表
create index 创建索引
create view 创建视图
alter table 增加表列，重定义表列，更改存储分配
drop table 删除表
drop index 删除索引
4.数据库控制语言dcl用来授予或回收访问数据库的某种特权，并控制数据库操纵事务发生的时间及效果，对数据库实行监视等。如：
grant 将权限或角色授予用户或其它角色
revoke 回收用户权限
roll 回滚，是当某个对话更改了数据库中的数据后，由于某种原因用户不想提交此更改时，oracle所采取的保护操作。这是一个把信息恢复到用户使update、insert、delete前最后提交的状态。
commit 提交。在完成数据库的插入，删除和修改操作时，只有当事务提交到数据库才算完成，有提交前只有操作数据库的本人才能看到，别人只有在最后提交完成才可以看到。
一个购物网站后台数据库实例：
现在我们回到用j2ee体系开发购物网站的主题，开始实战建购物网站的后台数据库。
为了实现购物网站的基本的功能，我们需要建立四个表：商品列表(products)、商品类型表(item)、订单列表(orders)和管理员列表(admin)。表结构如下所示：
item表结构（商品类型表)
字段名称 数据类型 允许空 主键/外键 备注
type_id integer(自动编号) 否 主键 商品类别id标记
type varchar2(30) 否 商品类别名称
product表结构(商品列表)
字段名称 数据类型 允许空 主键/外键 备注
product_id integer(自动编号) 否 主键 商品id标记
title varchar2(30) 否 商品名称
type_id integer 否 外键 商品类别标记
info varchar2(80) 是 商品简介
price number(16,2) 否 商品价格
orders表结构(订单列表)
字段名称 数据类型 允许空 主键/外键 备注
order_id integer(自动编号) 否 主键 订单id标记
name varchar2(20) 否 顾客姓名
address varchar2(100) 是 发货地址
tel number(16) 是 联系电话
email varchar2(30) 否 联系email
btime date 是 订购日期
product_id integer 否 外键 商品标记
uword varchar2(100) 是 顾客留言
admin表结构(管理员列表)
字段名称 数据类型 允许空 主键/外键 备注
admin_id integer(自动编号) 否 主键 管理员id标记
adminname varchar2(20) 否 管理员名称
password varchar2(20) 否 管理员密码
设计完表结构后，我们就要开始创建了。
创建表我想已经不是什么难事了，那么我们要注意的是product、item、orders这三个表之间的关联，还有自动编号。
下面是完整的sql语句，在后面我会给出详细的说明，你可以在sql*plus里对照着输入，也可以将它存为sql脚本文件，在sql*plus或sqlplus worksheet里执行。当然也可以把代码直接拷贝到sql*plus里执行！
代码：
rem ///by maxuan 开始///
create table item(
type_id integer not null,
type varchar2(30),
constraint item_pk primary key(type_id)
);
create table product(
product_id integer not null,
title varchar2(30) not null,
type_id integer not null,
info varchar2(80),
price number(16,2) not null,
constraint product_pk primary key (product_id),
constraint product_fk foreign key(type_id) references item(type_id)
);
create table orders(
order_id integer not null,
name varchar2(20) not null,
address varchar2(100),
tel number(16),
email varchar2(30) not null,
btime date,
product_id integer not null,
uword varchar2(100),
constraint orders_pk primary key(order_id),
constraint orders_fk foreign key(product_id) references product(product_id)
);
create table admin(
admin_id integer not null,
adminname varchar2(20) not null,
password varchar2(20) not null,
constraint admin_pk primary key(admin_id)
);
]]>
后台逻辑在eclipse里可以调试。而且有一个后台监控系统，感觉做的不错。出错的话，记录数据，sql，还有执行时间，模块什么的，基本上不用去拉log找异常了，一般都能看出错误来。
自带了权限系统。集成了工作流。
后期维护非常方便，随便哪个人都可以维护，以前如果代码写的不好，找bug能累死人，现在基本上来说是比较简单的，玩不出花样来，大家都是一个样。
可以生成完整的文档。对图形做的注释什么的，可以完全以htm,pdf的格式导出。这样文档和开发可以保持一致。
以前我们自己基于ibatis,webwork,spring，写插件通过加注释生成了很多文件来完成后台开发，但感觉麻烦的是即使你后台文件全部生成了，但前台哪些链接也蛮麻烦的，而且还要调试。我就想写个插件向导用模板来完成页面。现在看到eos，比我自己想象中做的还要好。
感觉对于不是很复杂的系统（我们公司做的大部分系统），天哪，我要懂这么多框架干嘛，struts,webwork,hibernate,ibatis,spring等等，用这些框架还要有很多繁琐的配置，于是就自己来做很多自动生成的工作。现在，只要懂一个eos就可以了，拖拖拉拉就可以完成，那我要这些框架干吗，不就是完成这个系统嘛。
虽然我感觉eos完全是面向过程的，但我们做的一般项目都不复杂，一般的项目完全可以用它来开发。但感觉会砸了很多人的饭碗，因为普通的开发人员，公司随便招个人就可以代替你。
]]>