摘要: 一、软件（利器） 1.1 Everything Everything可以快速的搜索你本地硬盘（仅支持NTFS格式）的所有文件，速度秒杀一切工具，缺点就是只能根据文件名来搜索，不能根据内容来（这个Google Desktop Search也不太好用），但是这已经足够了。 详情请 via 善用佳软-Everything:速度最快的文件名搜索工具 。 Tip...
阅读全文
1.decode(value,if1,then1,if2,then2,if3,then3,.....,else)
如果value等于if1时，DECODE函数的结果返回then1,....,如何不等于任何一个if值，则返回else
2.sign(变量1-变量2)
如果（变量1-变量2）大于0返回1,小于0返回-1,等于0返回0
3.COALESCE (expression_1, expression_2, ...,expression_n)
列表中第一个非空的表达式是函数的返回值，如果所有的表达式都是空值，最终将返回一个空值。
A和B是一对多的关系，在做更新操作的时候做如下动作：
A = dao.read(id);
List<B> bList = A.getBList();
bList.clear();
B b1 = new B();
b1.setA(A);
bList.add(b1);
B b2 = new B();
b2.setA(A);
bList.add(b2);
A.
比如我们现在有一个Parent的实体，在Parent实体当中有一个children的Set
由于这个children的数据并非非常重要，为了方便，我们在修改parent的时候，做法经常都是
1,清空children全部删了，再把新的children全部加进去。
今天早上做这一方面工作的时候遇到一个问题，就是在更新parent的时候，报了一个
Don't dereference a collection with cascade="all-delete-orphan"
的异常，经常一半个小时的查资料和调试，终于找到了解决问题的办法
刚刚开始我的做法为：
parent = parentService.findParentById(id);
parent.getChildren.clear();
parent.setChildren(newChildren);
parentService.updateparent(parent);
这样做一定会报出一个Don't dereference a collection with cascade="all-delete-orphan"的异常
原来是，对于parent的children这个Set，它本身是一个持久的集合，该集合存在于hibernate的对象池当中，通过
parent.setChildren(newChildren)的设置之后，本身已经将parent对children集合的引用指到对象池外的一个集合。
后来查询资料后的做法为：
parent = parentService.findParentById(id);
parent.getChildren.clear();
parent.getChildren.addAll(newChildren);
parentService.updateparent(parent);
做了几次测试，问题解决。
hbm配置如下：
<set lazy="true" name="children" cascade="all,delete-orphan" inverse="true">
<key column="PARENT_ID"/>
<one-to-many class="Child"/>
</set>
另外，hibernate 3已经将cascade当中的选项做了修改，现在已经没有了all-delete-orphan这个选项，虽然hibernate
内部还是支持这个选项……
mvn install -U -e -Dmaven.test.skip=true //安装跳过测试类,显示详细安装错误信息
mvn test -Dtest=myTest //运行某一个单元测试类
可能经常遇到这样的情况：
在数据库表中会有这样的一个字段用来区别记录的属性，如：在客户表中有一个字段表示客户级别，当这个记录为A时是一级客户，为B时是二级客户。在用hiberante做OR表示时类可能是这样的：
public class Customer{
private String flag; //表示客户的级别
...
}
然后，在程序中手动控制flag的值，但是这样当每个级的客户有不同的属性时Customer类将包含所有级别的属性，这样不是很好。
hibernate提供一个Discriminator映射的方法，就是把一个表映射成不同的类，有不同的属性。
public class Customer{
//包含所有级别的公共属性
...
}
public class CustomerA extends Customer{
//只包括一级客户的特有属性
}
public class CustomerB extends Customer{
//只包含二级客户特有的属性
}
这样更符合面向对象的原则，然后在hbm.xml中这样写：
<id name="id" type="int">
...
</id>
<discriminator column="flag" type="string" />
<!-- 公共属性的映射 -->
<subclass name="CustomerA" discriminator-value="A">
<!-- 一级客户特有属性的映射 -->
</subclass>
<subclass name="CustomerB" discriminator-value="B">
<!-- 二级客户特有属性的映射 -->
</subclass>
这样就可以单独的用CustomerA,CustomerB这样的实例了，做数据库修改时就不用关心flag字段的值了，会自动的加A或B。
如果是使用hibernate Annotation而不是xml来描述映谢关系，代码如下：
@Entity
@Table(name = "customer")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "flag", discriminatorType = DiscriminatorType.STRING)
public class Customer{
}
@Entity
@DiscriminatorValue(value = "A")
public class CustomerA extends Customer{
}
@Entity
@DiscriminatorValue(value = "B")
public class CustomerB extends Customer{
}
这样就可以了。
Case具有两种格式。简单Case函数和Case搜索函数。
--简单Case函数
CASE sex
WHEN '1' THEN '男'
WHEN '2' THEN '女'
ELSE '其他' END
--Case搜索函数
CASE WHEN sex = '1' THEN '男'
WHEN sex = '2' THEN '女'
ELSE '其他' END
这两种方式，可以实现相同的功能。简单Case函数的写法相对比较简洁，但是和Case搜索函数相比，功能方面会有些限制，比如写判断式。
还有一个需要注意的问题，Case函数只返回第一个符合条件的值，剩下的Case部分将会被自动忽略。
--比如说，下面这段SQL，你永远无法得到“第二类”这个结果
CASE WHEN col_1 IN ( 'a', 'b') THEN '第一类'
WHEN col_1 IN ('a') THEN '第二类'
ELSE'其他' END
下面我们来看一下，使用Case函数都能做些什么事情。
一，已知数据按照另外一种方式进行分组，分析。
有如下数据:(为了看得更清楚，我并没有使用国家代码，而是直接用国家名作为Primary Key)
国家（country） 人口（population）
中国 600
美国 100
加拿大 100
英国 200
法国 300
日本 250
德国 200
墨西哥 50
印度 250
根据这个国家人口数据，统计亚洲和北美洲的人口数量。应该得到下面这个结果。
洲 人口
亚洲 1100
北美洲 250
其他 700
想要解决这个问题，你会怎么做？生成一个带有洲Code的View，是一个解决方法，但是这样很难动态的改变统计的方式。
如果使用Case函数，SQL代码如下:
SELECT SUM(population),
CASE country
WHEN '中国' THEN '亚洲'
WHEN '印度' THEN '亚洲'
WHEN '日本' THEN '亚洲'
WHEN '美国' THEN '北美洲'
WHEN '加拿大' THEN '北美洲'
WHEN '墨西哥' THEN '北美洲'
ELSE '其他' END
FROM Table_A
GROUP BY CASE country
WHEN '中国' THEN '亚洲'
WHEN '印度' THEN '亚洲'
WHEN '日本' THEN '亚洲'
WHEN '美国' THEN '北美洲'
WHEN '加拿大' THEN '北美洲'
WHEN '墨西哥' THEN '北美洲'
ELSE '其他' END;
同样的，我们也可以用这个方法来判断工资的等级，并统计每一等级的人数。SQL代码如下；
SELECT
CASE WHEN salary <= 500 THEN '1'
WHEN salary > 500 AND salary <= 600 THEN '2'
WHEN salary > 600 AND salary <= 800 THEN '3'
WHEN salary > 800 AND salary <= 1000 THEN '4'
ELSE NULL END salary_class,
COUNT(*)
FROM Table_A
GROUP BY
CASE WHEN salary <= 500 THEN '1'
WHEN salary > 500 AND salary <= 600 THEN '2'
WHEN salary > 600 AND salary <= 800 THEN '3'
WHEN salary > 800 AND salary <= 1000 THEN '4'
ELSE NULL END;
二，用一个SQL语句完成不同条件的分组。
有如下数据
国家（country） 性别（sex） 人口（population）
中国 1 340
中国 2 260
美国 1 45
美国 2 55
加拿大 1 51
加拿大 2 49
英国 1 40
英国 2 60
按照国家和性别进行分组，得出结果如下
国家 男 女
中国 340 260
美国 45 55
加拿大 51 49
英国 40 60
普通情况下，用UNION也可以实现用一条语句进行查询。但是那样增加消耗(两个Select部分)，而且SQL语句会比较长。
下面是一个是用Case函数来完成这个功能的例子
SELECT country,
SUM( CASE WHEN sex = '1' THEN
population ELSE 0 END), --男性人口
SUM( CASE WHEN sex = '2' THEN
population ELSE 0 END) --女性人口
FROM Table_A
GROUP BY country;
这样我们使用Select，完成对二维表的输出形式，充分显示了Case函数的强大。
三，在Check中使用Case函数。
在Check中使用Case函数在很多情况下都是非常不错的解决方法。可能有很多人根本就不用Check，那么我建议你在看过下面的例子之后也尝试一下在SQL中使用Check。
下面我们来举个例子
公司A，这个公司有个规定，女职员的工资必须高于1000块。如果用Check和Case来表现的话，如下所示
CONSTRAINT check_salary CHECK
( CASE WHEN sex = '2'
THEN CASE WHEN salary > 1000
THEN 1 ELSE 0 END
ELSE 1 END = 1 )
如果单纯使用Check，如下所示
CONSTRAINT check_salary CHECK
( sex = '2' AND salary > 1000 )
女职员的条件倒是符合了，男职员就无法输入了。
简介: 外部连接和自联接 inner join(等值连接) 只返回两个表中联结字段相等的行 left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录 right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录 on 指定表间联结字段及其关系的等号 "=" 表达式, 返回 true 或 false. 当表达式返回 true 时, 则查询中包含该记录. ! 外部连接只能操作已存在于数据库中的数据
update (ctarticle as a left join ctclass as c on a.classid = c.classid) left join cttag as b on a.articleid = b.articleid
set tag=tag+' ', b.articleid=a.articleid, b.classid=a.classid, b.nclassid=a.nclassid
where a.classid=23 and a.nclassid=0 and tagid is not null
update (ctarticle as a left join (ctnclass as c left join ctclass as d on c.classid = d.classid) on a.nclassid = c.nclassid and a.classid = c.classid) left join cttag as b on a.articleid = b.articleid set tag=d.class+' '+c.nclass, b.articleid=a.articleid, b.classid=a.classid, b.nclassid=a.nclassid where a.classid=23 and a.nclassid=197;
更新操作
左连接中数据的筛选
insert into cttag(articleid,classid,nclassid) select a.articleid,a.classid,a.nclassid from ctarticle a left join cttag b on a.articleid=b.articleid where b.articleid is null
//本语句功能为, 显示主表的全部内容, 插入数据到副表中没有的数据
//主要作用为: 让数据减少冗余
上例中的延续
select a.*, b.*, c.*, d.*
from cttag as d left join ((ctarticle as a left join ctclass as b on a.classid=b.classid) left join ctnclass as c on a.nclassid=c.nclassid) on d.articleid=a.articleid;
显示文章表中的全部, 调用类别表中的栏目
select a.*, b.*, c.* from (ctarticle a left join ctclass b on a.classid=b.classid) left join ctnclass c on a.nclassid=c.nclassid
//作用, 有时在文章表中包含了在个别类别表中没有的数据, 用这个语法可以读出文章表的全部数据
//a 为 文章表, b 为主类别, c 为子类别
同上例, 选择追加数据时加上空格
insert into cttag(articleid,classid,nclassid,tag)
select a.articleid,a.classid,a.nclassid,d.class+' '+c.nclass
from (ctarticle as a left join (ctnclass c left join ctclass d on c.classid=d.classid) on a.classid=c.classid and a.nclassid=c.nclassid) left join cttag as b on a.articleid = b.articleid where a.classid=4 and a.nclassid=154;
连接n个表, 并追加数据到其中一个表, n=4
insert into cttag(articleid,classid,nclassid,tag)
select a.articleid,a.classid,a.nclassid,d.class+c.nclass
from (ctarticle as a left join (ctnclass c left join ctclass d on c.classid=d.classid) on a.classid=c.classid and a.nclassid=c.nclassid) left join cttag as b on a.articleid = b.articleid where a.classid=1 and a.nclassid=1;
//解读
插入到 表2(栏1,栏2,栏3,栏4)
选择 别名a.栏1, 别名a.栏2, 别名a.栏3, 别名d.栏4 加上 别名c.栏5
从 (表1 别名a 左连接 (表3 别名c 左连接 表4 别名d 在 别名c.栏2 等于 别名d.栏2) 在 别名a.栏2 等于 别名c.栏2 和 别名a.栏3=别名c.栏3) 左连接 表2 别名b 在 别名a.栏1 等于 别名b.栏1 在那里 别名a.栏2=1 和 别名a.栏3=1
连接两个表, 并追加数据到其中一个表
insert into cttag(articleid,classid,nclassid)
select a.articleid,a.classid,a.nclassid
from ctarticle as a left join cttag as b on a.articleid = b.articleid where a.classid=1 and a.nclassid=1;
//解读
插入到 表2(栏1,栏2,栏3)
选择 别名a.栏1, 别名a.栏2, 别名a.栏3
从 表1 别名a 左连接 表2 别名b 在 别名a.栏1 等于 别名b.栏1 在那里 别名a.栏4=1 和 别名a.栏5=1
左连接
同步两表的数据
update ctarticle a inner join cttag b on a.articleid = b.articleid set b.classid=a.classid, b.nclassid=a.nclassid;
//解读
更新 表1 别名a 联接 表2 别名2 在 别名a.栏1 等于 别名b.栏1 设置 别名b.栏2 更新为 别名a.栏2, 别名b.栏3 更新为 别名a.栏3
右外连接
select a.*, b.* from bunclass a right join ctclass b on a.classid=b.classid where a.nclassid=20
查询别名 a,b 表, 只匹配 b 表中的内容.
添加数据到连接表之一
insert into cttag ( tag, articleid ) select top 1 b.tag, a.articleid from ctarticle as a left join cttag as b on a.articleid = b.articleid where a.articleid order by a.articleid desc;
变通中的用法二
insert into bureply
select b.*, a.classid, a.nclassid
from article as a inner join reply as b on a.articleid = b.articleid
where classid=50;
实际应用中的变通
insert into butag ( tag, articleid, classid, nclassid)
select b.tag, a.articleid, a.classid, a.nclassid
from article as a inner join tag as b on a.articleid = b.articleid
where classid=24;
添加数据到其他表
insert into butag ( tag, articleid )
select b.tag, a.articleid
from article as a inner join tag as b on a.articleid = b.articleid
where a.articleid<>false;
//解读
添加到 接收表(列1,列2)
选择 别名b.列1, 别名a.列2
从 表1 表名a 联接 表2 表名b 在 别名a.列c 等于 别名b.列c
在哪里 别名a.列c 不等于 没有
实际应用中的变通
select b.tag, a.articleid, a.classid, a.nclassid
from article as a inner join tag as b on a.articleid = b.articleid
where a.classid=24;
查询
select b.tag, a.articleid
from article as a inner join tag as b on a.articleid = b.articleid
where a.articleid<>false;
//解读
选择 别名b.列, 别名a.列
从 表1 别名a 联接 表2 别名b 在 别名a.列c = 别名b.列c
在哪里 别名a.列c 不等于 没有
注: as 不是必要
SQL中IN,NOT IN,EXISTS,NOT EXISTS的用法和差别:
IN:确定给定的值是否与子查询或列表中的值相匹配。
IN 关键字使您得以选择与列表中的任意一个值匹配的行。
当要获得居住在 California、Indiana 或 Maryland 州的所有作者的姓名和州的列表时，就需要下列查询：
SELECT ProductID, ProductName FROM Northwind.dbo.Products WHERE CategoryID = 1 OR CategoryID = 4 OR CategoryID = 5
然而，如果使用 IN，少键入一些字符也可以得到同样的结果：
SELECT ProductID, ProductName FROM Northwind.dbo.Products WHERE CategoryID IN (1, 4, 5)
IN 关键字之后的项目必须用逗号隔开，并且括在括号中。
下列查询在 titleauthor 表中查找在任一种书中得到的版税少于 50% 的所有作者的 au_id，然后从 authors 表中选择 au_id 与
titleauthor 查询结果匹配的所有作者的姓名：
SELECT au_lname, au_fname FROM authors WHERE au_id IN (SELECT au_id FROM titleauthor WHERE royaltyper < 50)
结果显示有一些作者属于少于 50% 的一类。
NOT IN:通过 NOT IN 关键字引入的子查询也返回一列零值或更多值。
以下查询查找没有出版过商业书籍的出版商的名称。
SELECT pub_name FROM publishers WHERE pub_id NOT IN (SELECT pub_id FROM titles WHERE type = 'business')
使用 EXISTS 和 NOT EXISTS 引入的子查询可用于两种集合原理的操作：交集与差集。两个集合的交集包含同时属于两个原集合的所有元素。
差集包含只属于两个集合中的第一个集合的元素。
EXISTS:指定一个子查询，检测行的存在。
本示例所示查询查找由位于以字母 B 开头的城市中的任一出版商出版的书名：
SELECT DISTINCT pub_name FROM publishers WHERE EXISTS (SELECT * FROM titles WHERE pub_id = publishers.pub_id AND type =
'business')
SELECT distinct pub_name FROM publishers WHERE pub_id IN (SELECT pub_id FROM titles WHERE type = 'business')
两者的区别:
EXISTS:后面可以是整句的查询语句如:SELECT * FROM titles
IN:后面只能是对单列:SELECT pub_id FROM titles
NOT EXISTS:
例如，要查找不出版商业书籍的出版商的名称：
SELECT pub_name FROM publishers WHERE NOT EXISTS (SELECT * FROM titles WHERE pub_id = publishers.pub_id AND type =
'business')
下面的查询查找已经不销售的书的名称:
SELECT title FROM titles WHERE NOT EXISTS (SELECT title_id FROM sales WHERE title_id = titles.title_id)
可能经常遇到这样的情况：
在数据库表中会有这样的一个字段用来区别记录的属性，如：在客户表中有一个字段表示客户级别，当这个记录为A时是一级客户，为B时是二级客户。在用hiberante做OR表示时类可能是这样的：
public class Customer{
private String flag; //表示客户的级别
...
}
然后，在程序中手动控制flag的值，但是这样当每个级的客户有不同的属性时Customer类将包含所有级别的属性，这样不是很好。
hibernate提供一个Discriminator映射的方法，就是把一个表映射成不同的类，有不同的属性。
public class Customer{
//包含所有级别的公共属性
...
}
public class CustomerA extends Customer{
//只包括一级客户的特有属性
}
public class CustomerB extends Customer{
//只包含二级客户特有的属性
}
这样更符合面向对象的原则，然后在hbm.xml中这样写：
<id name="id" type="int">
...
</id>
<discriminator column="flag" type="string" />
<!-- 公共属性的映射 -->
<subclass name="CustomerA" discriminator-value="A">
<!-- 一级客户特有属性的映射 -->
</subclass>
<subclass name="CustomerB" discriminator-value="B">
<!-- 二级客户特有属性的映射 -->
</subclass>
这样就可以单独的用CustomerA,CustomerB这样的实例了，做数据库修改时就不用关心flag字段的值了，会自动的加A或B。
如果是使用hibernate Annotation而不是xml来描述映谢关系，代码如下：
@Entity
@Table(name = "customer")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "flag", discriminatorType = DiscriminatorType.STRING)
public class Customer{
}
@Entity
@DiscriminatorValue(value = "A")
public class CustomerA extends Customer{
}
@Entity
@DiscriminatorValue(value = "B")
public class CustomerB extends Customer{
}
这样就可以了。