少年阿賓

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)這樣的寫發是通不過的?。。?/p>

     摘要: 命令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類線程。