少年阿宾

SQL> create table lee(id number,name varchar2(100),score number,constraint pk_lee primary key(id));
 
Table created

 SQL> desc lee
Name  Type          Nullable Default Comments
----- ------------- -------- ------- --------
ID    NUMBER                                 
NAME  VARCHAR2(100) Y                        
SCORE NUMBER        Y                        
 
SQL> alter table lee add createtime date;
 
Table altered
 
SQL> desc lee
Name       Type          Nullable Default Comments
---------- ------------- -------- ------- --------
ID         NUMBER                                 
NAME       VARCHAR2(100) Y                        
SCORE      NUMBER        Y                        
CREATETIME DATE          Y                        
 
SQL> alter table lee modify createtime nvarchar2(100);
 
Table altered
 
SQL> desc lee
Name       Type           Nullable Default Comments
---------- -------------- -------- ------- --------
ID         NUMBER                                  
NAME       VARCHAR2(100)  Y                        
SCORE      NUMBER         Y                        
CREATETIME NVARCHAR2(100) Y                        
 
SQL> alter table lee rename column createtime to mytime;
 
Table altered
 
SQL> desc lee
Name   Type           Nullable Default Comments
------ -------------- -------- ------- --------
ID     NUMBER                                  
NAME   VARCHAR2(100)  Y                        
SCORE  NUMBER         Y                        
MYTIME NVARCHAR2(100) Y                        
 
SQL> alter table lee modify mytime date;
 
Table altered
 
SQL> desc lee
Name   Type          Nullable Default Comments
------ ------------- -------- ------- --------
ID     NUMBER                                 
NAME   VARCHAR2(100) Y                        
SCORE  NUMBER        Y                        
MYTIME DATE          Y                        
 
SQL> desc lee
Name   Type          Nullable Default Comments
------ ------------- -------- ------- --------
ID     NUMBER                                 
NAME   VARCHAR2(100) Y                        
SCORE  NUMBER        Y                        
MYTIME DATE          Y                         
                  
 
SQL> alter table lee rename column mytime to createtime;
 
Table altered
 
SQL> desc lee
Name       Type          Nullable Default Comments
---------- ------------- -------- ------- --------
ID         NUMBER                                 
NAME       VARCHAR2(100) Y                        
SCORE      NUMBER        Y                        
CREATETIME DATE          Y                         
 
SQL> alter table lee drop column createtime;
 
Table altered
 
SQL> desc lee
Name  Type          Nullable Default Comments
----- ------------- -------- ------- --------
ID    NUMBER                                 
NAME  VARCHAR2(100) Y                        
SCORE NUMBER        Y                        
 
SQL>

//这里是测试UserDao userDao=EasyMock.createMock(UserDao.class);这种形式的：

package com.abin.lee.mock;

public class User {
 private int id;
 private String userName;
 private String passWord;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getUserName() {
  return userName;
 }
 public void setUserName(String userName) {
  this.userName = userName;
 }
 public String getPassWord() {
  return passWord;
 }
 public void setPassWord(String passWord) {
  this.passWord = passWord;
 }
}

package com.abin.lee.mock;

public interface UserDao {
 User query(String id);
}

package com.abin.lee.mock;

public class UserDaoImpl implements UserDao{

 public User query(String id) {
  User user=null;
  if(id.equals("1")){
   user=new User();
   user.setId(1);
   user.setUserName("abin1");
   user.setPassWord("varyall1");
  }
  if(id.equals("2")){
   user=new User();
   user.setId(2);
   user.setUserName("abin2");
   user.setPassWord("varyall2");
  }
  return user;
 }

}

package com.abin.lee.mock;

public interface UserService {
 User query(String id);
}

package com.abin.lee.mock;

public class UserServiceImpl implements UserService{
 private UserDao userDao;
 public User query(String id){
  return this.userDao.query(id);
 }
 
 public UserDao getUserDao() {
  return userDao;
 }

 public void setUserDao(UserDao userDao) {
  this.userDao = userDao;
 }
 
}

测试代码：

package com.abin.lee.mock;

import org.easymock.EasyMock;
import org.junit.Assert;
import org.junit.Test;

public class UserMock {
 @Test
 public void test(){
  User expectedUser=new User();
  expectedUser.setId(1);
  expectedUser.setUserName("abin1");
  expectedUser.setPassWord("varyall1");
  UserDao userDao=EasyMock.createMock(UserDao.class);
  EasyMock.expect(userDao.query("1")).andReturn(expectedUser);
  EasyMock.replay(userDao);
  UserServiceImpl service=new UserServiceImpl();
  service.setUserDao(userDao);
  User user=service.query("1");
  Assert.assertNotNull(user);
  Assert.assertEquals(1, user.getId());
  Assert.assertEquals("abin1", user.getUserName());
  Assert.assertEquals("varyall1", user.getPassWord());
  EasyMock.verify(userDao);
 }
}





测试方法2：

package com.abin.lee.mock;

import org.easymock.EasyMock;
import org.easymock.IMocksControl;
import org.junit.Assert;
import org.junit.Test;

public class UsersMock {
 @Test
 public void test(){
  User expectedUser=new User();
  expectedUser.setId(2);
  expectedUser.setUserName("abin2");
  expectedUser.setPassWord("varyall2");
  IMocksControl mock=EasyMock.createNiceControl();
  UserDao userDao=mock.createMock(UserDao.class);
  EasyMock.expect(userDao.query("2")).andReturn(expectedUser);
  mock.replay();
  UserServiceImpl service=new UserServiceImpl();
  service.setUserDao(userDao);
  User user=service.query("2");
  Assert.assertNotNull(user);
  Assert.assertEquals(2, user.getId());
  Assert.assertEquals("abin2", user.getUserName());
  Assert.assertEquals("varyall2", user.getPassWord());
  mock.verify();
  mock.resetToNice();
  
 }

}

sql 单表/多表查询去除重复记录

单表distinct

多表group by

group by 必须放在 order by 和 limit之前，不然会报错

************************************************************************************

1、查找表中多余的重复记录，重复记录是根据单个字段（peopleId）来判断

select * from people
where peopleId in (select  peopleId  from  people  group  by  peopleId  having  count(peopleId) > 1)

2、删除表中多余的重复记录，重复记录是根据单个字段（peopleId）来判断，只留有rowid最小的记录
delete from people
where peopleId  in (select  peopleId  from people  group  by  peopleId   having  count(peopleId) > 1)
and rowid not in (select min(rowid) from  people  group by peopleId  having count(peopleId )>1)

3、查找表中多余的重复记录（多个字段）
select * from vitae a
where (a.peopleId,a.seq) in  (select peopleId,seq from vitae group by peopleId,seq  having count(*) > 1)

4、删除表中多余的重复记录（多个字段），只留有rowid最小的记录
delete from vitae a
where (a.peopleId,a.seq) in  (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)

5、查找表中多余的重复记录（多个字段），不包含rowid最小的记录
select * from vitae a
where (a.peopleId,a.seq) in  (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)

(二)
比方说
在A表中存在一个字段“name”，
而且不同记录之间的“name”值有可能会相同，
现在就是需要查询出在该表中的各记录之间，“name”值存在重复的项；
Select Name,Count(*) From A Group By Name Having Count(*) > 1

如果还查性别也相同大则如下:
Select Name,sex,Count(*) From A Group By Name,sex Having Count(*) > 1

(三)
方法一

declare @max integer,@id integer

declare cur_rows cursor local for select 主字段,count(*) from 表名 group by 主字段 having count(*) >； 1

open cur_rows

fetch cur_rows into @id,@max

while @@fetch_status=0

begin

select @max = @max -1

set rowcount @max

delete from 表名 where 主字段 = @id

fetch cur_rows into @id,@max
end

close cur_rows

set rowcount 0

方法二

＂重复记录＂有两个意义上的重复记录，一是完全重复的记录，也即所有字段均重复的记录，二是部分关键字段重复的记录，比如Name字段重复，而其他字段不一定重复或都重复可以忽略。

1、对于第一种重复，比较容易解决，使用

select distinct * from tableName

就可以得到无重复记录的结果集。

如果该表需要删除重复的记录（重复记录保留1条），可以按以下方法删除

select distinct * into #Tmp from tableName

drop table tableName

select * into tableName from #Tmp
drop table #Tmp

发生这种重复的原因是表设计不周产生的，增加唯一索引列即可解决。

2、这类重复问题通常要求保留重复记录中的第一条记录，操作方法如下

假设有重复的字段为Name,Address，要求得到这两个字段唯一的结果集

select identity(int,1,1) as autoID, * into #Tmp from tableName

select min(autoID) as autoID into #Tmp2 from #Tmp group by Name,autoID

select * from #Tmp where autoID in(select autoID from #tmp2)

最后一个select即得到了Name，Address不重复的结果集（但多了一个autoID字段，实际写时可以写在select子句中省去此列）

(四)
查询重复

select * from tablename where id in (select id from tablename

group by id

having count(id) > 1

)

3、查找表中多余的重复记录（多个字段）
select * from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)

运行会产生问题，where(a.peopleId,a.seq)这样的写发是通不过的！！！

     摘要: 命令1：监听命令 nc -l -p port nc -l -p port > e:\log.dat nc -l -v -p port 参数解释： -l：监听端口，监听入站信息 -p：后跟本地端口号 -v：显示端口的信息，如果使用-vv的话，则会显示端口更详细的信息 提示：一般大家都爱用-vv nc -l...  阅读全文

package chn.lass.liu.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapTest {
 public static Map<String,String> createMap(){
  Map<String,String> map=new HashMap<String, String>();
  map.put("a", "111");
  map.put("b", "222");
  return map;
 }
 public static void parseMap(Map<String,String> map){
  for(Iterator it=map.entrySet().iterator();it.hasNext();){
   Map.Entry entry=(Map.Entry)it.next();
   System.out.println("key="+entry.getKey());
   System.out.println("value="+entry.getValue());
   if("a".equals(entry.getKey())){
    it.remove();
   }
  }
  for(Iterator it=map.entrySet().iterator();it.hasNext();){
   Map.Entry entry=(Map.Entry)it.next();
   System.out.println("key1="+entry.getKey());
   System.out.println("value1="+entry.getValue());
  }
 }
 public static void main(String[] args) {
  Map<String,String> map=createMap();
  parseMap(map);
 }
}

package chn.lass.liu.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest {
 public static List<String> createList(){
  List<String> list=new ArrayList<String>();
  for(int i=0;i<5;i++){
   list.add(""+i);
  }
  return list;
 }
 public static void ParseList(List<String> list){
  for(Iterator it=list.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("list is:"+its);
   it.remove();
  }
 }
 public static void main(String[] args) {
   List<String> list=createList();
   ParseList(list);
 }
}

package chn.lass.liu.collection;

import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
 public static Vector<String> createVector(){
  Vector<String> vector=new Vector<String>();
  vector.addElement("aa");
  vector.addElement("bb");
  return vector;
 }
 public static void parseVector(Vector<String> vector){
  for(Iterator it=vector.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("its is:"+its);
  }
 }
 public static void main(String[] args) {
  Vector<String> vector=createVector();
  parseVector(vector);
 }
}

package chn.lass.liu.collection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest {
 public static Set<String> createSet(){
  Set<String> set=new HashSet<String>();
  set.add("a");
  set.add("b");
  return set;
 }
 public static void parseSet(Set<String> set){
  for(Iterator it=set.iterator();it.hasNext();){
   String its=(String)it.next();
   System.out.println("its is:"+its);
  }
 }
 public static void main(String[] args) {
  Set<String> set=createSet();
  parseSet(set);
 }
}

 

　Netcat 或者叫 nc 是 Linux 下的一个用于调试和检查网络工具包。可用于创建 TCP/IP 连接，最大的用途就是用来处理 TCP/UDP 套接字。

　　这里我们将通过一些实例来学习 netcat 命令。

　　1. 在服务器-客户端架构上使用 Netcat

　　netcat 工具可运行于服务器模式，侦听指定端口

　然后你可以使用客户端模式来连接到 2389 端口：

　　现在如果你输入一些文本，它将被发送到服务器端：

　　在服务器的终端窗口将会显示下面内容：

　　2. 使用 Netcat 来传输文件

　　netcat 工具还可用来传输文件，在客户端，假设我们有一个 testfile 文件：

　　而在服务器端有一个空文件名为 test

　　然后我们使用如下命令来启用服务器端：

　　紧接着运行客户端：

　　然后你停止服务器端，你可以查看 test 内容就是刚才客户端传过来的 testfile 文件的内容：

　　3. Netcat 支持超时控制

　　多数情况我们不希望连接一直保持，那么我们可以使用 -w 参数来指定连接的空闲超时时间，该参数紧接一个数值，代表秒数，如果连接超过指定时间则连接会被终止。

　　服务器:

　　客户端:

　　该连接将在 10 秒后中断。

　　注意: 不要在服务器端同时使用 -w 和 -l 参数，因为 -w 参数将在服务器端无效果。

　　4. Netcat 支持 IPv6

netcat 的 -4 和 -6 参数用来指定 IP 地址类型，分别是 IPv4 和 IPv6：

　　服务器端：

　　客户端：

　　然后我们可以使用 netstat 命令来查看网络的情况：

　　接下来我们看看IPv6 的情况：

　　服务器端：

　　客户端：

　　再次运行 netstat 命令：

　　前缀是 tcp6 表示使用的是 IPv6 的地址。

　　5. 在 Netcat 中禁止从标准输入中读取数据

　　该功能使用 -d 参数，请看下面例子：

　　服务器端：

　　客户端：

　　你输入的 Hi 文本并不会送到服务器端。

　　6. 强制 Netcat 服务器端保持启动状态

　　如果连接到服务器的客户端断开连接，那么服务器端也会跟着退出。

　　服务器端：

　　客户端：

　　服务器端：

　　上述例子中，但客户端断开时服务器端也立即退出。

　　我们可以通过 -k 参数来控制让服务器不会因为客户端的断开连接而退出。

　　服务器端：

　　客户端：

　　服务器端：

　　7. 配置 Netcat 客户端不会因为 EOF 而退出

　　Netcat 客户端可以通过 -q 参数来控制接收到 EOF 后隔多长时间才退出，该参数的单位是秒：

　　客户端使用如下方式启动：

　　现在如果客户端接收到 EOF ，它将等待 5 秒后退出。

　　8. 使用 Netcat 来处理 UDP 协议

　　netcat 默认是使用 TCP 协议，但也支持 UDP，可使用 -u 参数来启用 UDP 协议通讯。

　　服务器端：

　客户端：

　　这样客户端和服务器端都使用了 UDP 协议，可通过 netstat 命令来查看：

　　英文原文：nc-command-examples

下面的例子通过wait()来取代忙等待机制，当收到通知消息时，notify当前Monitor类线程。