SELECT UPPER(F.TABLESPACE_NAME) "表空間名",
D.TOT_GROOTTE_MB "表空間大小(M)",
D.TOT_GROOTTE_MB - F.TOTAL_BYTES "已使用空間(M)",
TO_CHAR(ROUND((D.TOT_GROOTTE_MB - F.TOTAL_BYTES) / D.TOT_GROOTTE_MB * 100,
2),
'990.99') "使用比",
F.TOTAL_BYTES "空閑空間(M)",
F.MAX_BYTES "最大塊(M)"
FROM (SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES) / (1024 * 1024), 2) TOTAL_BYTES,
ROUND(MAX(BYTES) / (1024 * 1024), 2) MAX_BYTES
FROM SYS.DBA_FREE_SPACE
GROUP BY TABLESPACE_NAME) F,
(SELECT DD.TABLESPACE_NAME,
ROUND(SUM(DD.BYTES) / (1024 * 1024), 2) TOT_GROOTTE_MB
FROM SYS.DBA_DATA_FILES DD
GROUP BY DD.TABLESPACE_NAME) D
WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME
ORDER BY 4 DESC
--order by F.TABLESPACE_NAME


select OSUSER,PROGRAM,USERNAME,SCHEMANAME,B.Cpu_Time,STATUS,B.SQL_TEXT
from V$SESSION A LEFT JOIN V$SQL B ON A.SQL_ADDRESS=B.ADDRESS AND A.SQL_HASH_VALUE=B.HASH_VALUE order by b.cpu_time desc

1：The food is delicious!  好吃
2：your son/daughter is so cute 你的孩子很可愛
3：your chinese is really surprising  你的中文令人驚訝
4：can you speak slowly? 請您說得慢些好嗎？
5：come with me. 跟我來
6： congratulations. 恭喜恭喜
7： After you
8：Slow down! 慢點
9：Watch out! 當心
10：I beg your pardon？
11： I am a football fan

SELECT UPPER(F.TABLESPACE_NAME) "表空間名",
D.TOT_GROOTTE_MB "表空間大小(M)",
D.TOT_GROOTTE_MB - F.TOTAL_BYTES "已使用空間(M)",
TO_CHAR(ROUND((D.TOT_GROOTTE_MB - F.TOTAL_BYTES) / D.TOT_GROOTTE_MB * 100,
2),
'990.99') "使用比",
F.TOTAL_BYTES "空閑空間(M)",
F.MAX_BYTES "最大塊(M)"
FROM (SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES) / (1024 * 1024), 2) TOTAL_BYTES,
ROUND(MAX(BYTES) / (1024 * 1024), 2) MAX_BYTES
FROM SYS.DBA_FREE_SPACE
GROUP BY TABLESPACE_NAME) F,
(SELECT DD.TABLESPACE_NAME,
ROUND(SUM(DD.BYTES) / (1024 * 1024), 2) TOT_GROOTTE_MB
FROM SYS.DBA_DATA_FILES DD
GROUP BY DD.TABLESPACE_NAME) D
WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME
ORDER BY 4 DESC
--order by F.TABLESPACE_NAME


select OSUSER,PROGRAM,USERNAME,SCHEMANAME,B.Cpu_Time,STATUS,B.SQL_TEXT
from V$SESSION A LEFT JOIN V$SQL B ON A.SQL_ADDRESS=B.ADDRESS AND A.SQL_HASH_VALUE=B.HASH_VALUE order by b.cpu_time desc

1 08/06  A組 瑞士 00:00 捷克 巴塞爾               0:1
2 08/06  A組 葡萄牙 02:45 土耳其 日內瓦           2:0
3 09/06  B組 奧地利 00:00 克羅地亞 維也納         0:1
4 09/06  B組 德國 02:45 波蘭 克拉根佛特           2:0
5 10/06  C組 羅馬尼亞 00:00 法國 蘇黎世           0:0
6 10/06  C組 荷蘭 02:45 意大利 伯爾尼             3:0
7 11/06  D組 西班牙 00:00 俄羅斯 因斯布魯克       4:1
8 11/06  D組 希臘 02:45 瑞典 薩爾茨堡             0:2
9 12/06  A組 捷克 00:00 葡萄牙 日內瓦     3:1
10 12/06 A組 瑞士 02:45 土耳其 巴塞爾
11 13/06 B組 克羅地亞 00:00 德國 克拉根佛特
12 13/06 B組 奧地利 02:45 波蘭 維也納
13 14/06 C組 意大利 00:00 羅馬尼亞 蘇黎世
14 14/06 C組 荷蘭 02:45 法國 伯爾尼
15 15/06 D組 瑞典 00:00 西班牙 因斯布魯克
16 15/06 D組 希臘 02:45 俄羅斯 薩爾茨堡
17 16/06 A組 瑞士 02:45 葡萄牙 巴塞爾
18 16/06 A組 土耳其 02:45 捷克 日內瓦
19 17/06 B組 奧地利 02:45 德國 維也納
20 17/06 B組 波蘭 02:45 克羅地亞 克拉根佛特
21 18/06 C組 荷蘭 02:45 羅馬尼亞 伯爾尼
22 18/06 C組 法國 02:45 意大利 蘇黎世
23 19/06 D組 希臘 02:45 西班牙 薩爾茨堡
24 19/06 D組 俄羅斯 02:45 瑞典 因斯布魯克
25 20/06 1/4決賽 A組第1 02:45 B組第2 巴塞爾
26 21/06 1/4決賽 B組第1 02:45 A組第2 維也納
27 22/06 1/4決賽 C組第1 02:45 D組第2 巴塞爾
28 23/06 1/4決賽 D組第1 02:45 C組第2 維也納
29 26/06 半決賽 第25場勝者 02:45 第26場勝者 巴塞爾
30 27/06 半決賽 第27場勝者 02:45 第28場勝者 維也納
31 30/06 決賽 第29場勝者 02:45 第30場勝者 維也納

本人比較看好西班牙

 

 

    在開發過程中遇到這樣一個問題：
    2008-06-02 16:29:23,262 WARN [org.hibernate.util.JDBCExceptionReporter] SQL Error: 30036, SQLState: 99999
2008-06-02 16:29:23,263 ERROR [org.hibernate.util.JDBCExceptionReporter] ORA-30036: unable to extend segment by 1024 in undo tablespace 'UNDOTBS2'
后來查資料才發現是Undo表空間的問題。查看了一下Undo表空間剩的空間已經很少了。這種問題解決方法如下：

    

UNDO表空間用于存放UNDO數據,當執行DML操作(INSERT,UPDATE和DELETE)時,oracle會將這些操作執行前的舊數據寫入到UNDO段,在oracle9i之前,管理UNDO數據時使用(Rollback Segment)完成的.從oracle9i開始,管理UNDO數據不僅可以使用回滾段,還可以使用UNDO表空間.因為規劃和管理回滾段比較復雜,所有oracle database 10g已經完全丟棄用回滾段.并且使用UNDO表空間來管理UNDO數據.

1:查看所有的Undo表空間

SELECT * FROM dba_tablespaces where contents='UNDO'

2:Undo大小計算公式：

SELECT ((UR * (UPS * DBS)) + (DBS * 24))/1048576 AS "MB"
FROM (SELECT value AS UR
FROM v$parameter
WHERE name = 'undo_retention'),
(SELECT (SUM(undoblks)/SUM
(((end_time-begin_time)*86400))) AS UPS
FROM v$undostat),
(SELECT value AS DBS
FROM v$parameter
WHERE name = 'db_block_size');
3：修改Undo表空間大小

 先刪除原來的表空間：
 drop tablespace UNDOTBS2 including contents and datafiles
 再建立一個和原來名稱一樣的表空間
 create undo tablespace UNDOTBS2 datafile '/home/oracle/oradata/depsight/undotbs2.dbf' size 50m

    想象一下，把所有的失望和希望都強加在一個人身上，留下的是什么那，那得把大地壓得顫抖。 

    沿著鴿子的哨音，我尋找著你，高高的森林擋住了天空，小路上一顆迷途的蒲公英，把我引向藍灰色的湖泊，在微微搖晃的倒影中。我找到了你。

    這詩歌怎么樣啊，《迷途》。猜猜誰寫的。

    如果說弗羅斯特的選擇是無法改變而且使它變得偉大，那么普通人的選擇又能算什么那。

    我靜靜回想你的眼神，但我永遠無法讀懂那里含有什么，是期盼還是討厭。

    高考。意味著什么那，解脫、或是一段歷史的結束，都一樣吧。

    還記得史鐵生說得好啊：女人對于你才是一個必然，而我對于你只是一個偶然。改編一下：

    高考對于我們來說是一個必然，考上了才是一個偶然。

    你對于我來說就跟其他的一樣，其他的也跟你一樣。當我看到他們我就想起你，而我看到你是就會忘記他們。

    多么美好的生活，就這樣過去啦，不會回來了，在這里消逝，溶釋在不知道的地方。

距離高考就剩下四十天了，從來沒有象現在這樣的考慮過一些事情。

每當我想到在這兒度過的一天，就想起一句話: 復課一年的生活將是你一生的財富--純屬放屁的一句話不知道害了多少像我一樣的學生，如果將來的一天再有人跟我說這句話，我會吃了他。

在這兒受盡了窩囊氣，老師不象老師象畜生，女生比男人還男人，男生比女人還女人。這些可以忍受而且必須忍受。

在這兒不知為什么從沒想起過以前的跟高中同學在一起的歲月，就像一個世外的人，跟著果子每天吃飯睡覺上課跑操，突然間變得淡然了，一切都不重要了。

從沒想過自己有一天會考上家人期望的大學，只是自己一個人在這兒思考一些問題，有時候去喝點酒或者打打臺球什么的。

蒼涼的生活再有四十天就要結束了--徹底的結束。在這兒得一切都將成為過去，可能存在我的記憶中，也可能被我遺忘生活跟我開了一個玩笑，呵呵，勇氣，責任，挫折，汗水，成績，理想，情感，憂郁，都他媽的將要去啦。

曾想過寫一篇長一點得東西記錄這一年的心路歷程，后來放棄了，自己根本就不會寫什么東西，經歷就像一杯水你喝了它，它就消失，你倒了它它也是沒有了，結果都一樣，被子終將空的。留下的只是一些零碎的片段，希望它是完整的，但它永遠不會。

在正確的時間遇上錯誤的人，注定是一聲嘆息；在錯誤的時間遇到對的人，注定是一場悲傷。這話說的太好了，每聽一遍都是眼淚模糊。

幻想，是美好的，生活在自己想象的世界里是完美的。憧憬，悵惘，期待，虛偽，流氓，拳擊，讀書，音樂，電影，每天充斥著我，生活就是這個樣子的嗎？幸福在哪里？

天空，晴朗，云彩，時光，流水，塵土，星空，黎明，這是幸福。

孤獨，寂寞，惆悵，失落，燦爛，憂傷，浮躁，平淡，這也是幸福。

理想，信念，執著，信仰，支撐，拼搏，努力，堅持，就像平凡的偉大的土地在我們心里生長，這同樣是幸福。

萎靡，沉醉，瘋狂，墮落，枯萎，這不是幸福，這是什么那？

生活是肥皂，生活是牙膏，生活是大寶，人生必落俗。

平靜，煩惱，壓力，浪潮，激動，憤怒，沒什么可以阻擋的。真的嗎？

白云蒼狗，過眼云煙，花開花落，云卷云舒。

就像阿Q一樣有時候也想一下這個東西，就是“女......”我們要繼續想下去的。

現在老覺得女孩魅惑迷離的眼神是那么的可愛，值得留戀。那就是烙印打在心上了。

男人在夜深人靜的時候才會留下眼淚撫摸自己的傷口，生活跟我們開了一個玩笑，希望這一切能讓我在以后想起來的時候會有多點的釋然，少一點的無奈，少一點傷感。

可能所有的人都能理解我的心情。看過這篇日志的人啊，愿上帝保佑你們，愿我的忠誠助你們一臂之力。

HashMap輸出排序，以前寫的接口沒有考慮這個問題，現在輸出要求排序，可以在得到Map結果后進行如下操作對數據進行排序：

Object[] key =   map.keySet().toArray();
//升序排序
        Arrays.sort(key);
       
        for(int i=0;i<key.length;++i)
        {
         System.out.println("Key_Id=="+key[i]+"Key_Value===="+map.get(key[i]));;
        }

我對以前對漢龍集團根本不了解，可今天看了一個貼子說是漢龍集團捐助的5所希望小學在地震中屹立不倒，
師生的生命得以挽救，心里特別震撼，當時的集團一個主任負責監管建設這五所希望小學，非常嚴格，
10年之前，10年之后，想起這，人的感動不由心生，好人有好報！但是就是這樣嚴格按照工程質量建造的學校，因為在地震中沒有倒，而被人稱做“奇跡”，為何？我不說大家也明白。其它的建設的都是垃圾工程。
好人有好報，良心被狼吃了的人也必遭天遣！

距高考80天的感想

1.每天生活都是一個樣子,教室-廁所-食堂-宿舍,看見的人也是一樣,男生-女生-老師-還有畜生,這樣的生活太他媽的爽了.

2.每天有固定的時間看書\睡覺\吃飯\跑操.連上個廁所的時間每天都是一樣的,這樣的生活其實一天就可以了,沒有必要每天都這樣.

3.每當我看都畜生的時候我就想自己真是個幸運的孩子啊,在這個時候才遇見他,而不是整個高中,真他嗎的是幸福啊.

4.并不是每天都能看到的人,但為什么總是在尷尬的時候出現了,就象是一個雷鋒在發揚釘子般的鉆的精神,突然就鉆出來拉.

5.我要在地上畫滿窗子,讓所有習慣黑暗的眼睛都習慣光明,高三的學子們,掰著你們的爪子算一算你們就剩下幾十天了,我在這里給你們祝福了.

6.我們不要嫉恨畜生,他們也是很好的呀,他們吃飯睡覺喝水撒尿跟我們一樣,不過他們的思想跟我們不大一樣,他們是牲畜的思想--僅此而已.

7.這里上學的有十種人.1.上學遲到的,2.上課睡覺的,3.上課看課外書的,4.上課說話的,5.老師不講課睡不著覺的,6.吃飯把漱口水吐你鞋上的,7.再你吃飯的時候突然把你的饅頭撞掉的而且還很橫的,8.你在睡覺的時候突然闖入什么都不說的,9.半夜三更在樓道唱歌的,10沒有女朋友跟你說他有的.

8.要原諒他們啊,并且要為他們祈禱啊----滾你娘的吧.老子不在乎.

同志們,革命尚未成功同志仍需努力,我們要好好學習天天向上啊,為什么那?

轉自別處：
    1：抽象類：
                    有時候，我們可能想要構造一個很抽象的父類對象，它可能僅僅代表一個分類或抽象概念，它的實例沒有任何意義，因此不希望它能被實例化。例如：有一個父類“水果（Fruit）”，它有幾個子類“蘋果（Apple）”、“橘子（Orange）”、“香蕉（Banana）”等。水果在這里僅僅只是作為一個分類，顯然水果的實例沒有什么意義（就好像一個人如果告訴你他買了一些水果但是卻不告訴你是蘋果還是橘子，你很難想象他到底買的是什么。） 。而水果類又要能被子類化，這就要求我們使用抽象類（abstract class）來解決這個問題。
在java中，通過在class關鍵字前增加abstract修飾符，就可以將一個類定義成抽象類。抽象類不能被實例化。例如：
          定義抽象類水果（Fruit）
          public abstract class Fruit {
                  ……
          }
           如果我們試圖用以下語句來獲得一個實例，將無法編譯成功。
           Fruit fruit = new Fruit();
而我們仍然可以構造水果類的子類，如：
          子類“蘋果（Apple）”
           public class Apple extends Fruit {
                   ……
           }
          子類“橘子（Orange）”
           public class Orange extends Fruit {
                   ……
           }
這樣就達到我們的目的了。
抽象類除了能象普通類一樣可以擁有一般的屬性和方法，也可以擁有抽象方法（abstract method）。例如：
           抽象類“形狀（Shape）”擁有抽象方法draw()。
           public abstract class Shape {
                  ……
                  public abstract void draw();
                  ……
           }
抽象方法與抽象的行為相對應，通常是這個行為對父對象沒有意義，而子對象有具體動作。例如方法draw()對于類Shape沒有意義，而類Shape的子類矩形（Rectangle）的方法draw()可以有實際的動作（根據矩形的四個頂點畫出矩形的四個邊），子類圓（Circle）的方法draw()也可以有實際的動作（根據圓心和半徑畫出圓周）。
抽象類可以有抽象方法也可以沒有抽象方法；但是如果一個類有抽象方法，那這個類只能定義為抽象類。
           如果按照以下代碼類“形狀（Shape）”仍然擁有抽象方法draw()，但沒有定義為抽象類，將會編譯失敗。
           public class Shape {
                  ……
                  public abstract void draw();
                  ……
           }
抽象方法還有一個特點是，它強迫子類要么仍然保持抽象性（即不具體實現該方法并仍然定義為抽象類），要么具體表現出這個方法的行為（實現具體的動作或者通過拋出UnsupportedOperationException異常來表明不支持該行為）。這樣也可以強化多態性。

2：接口（interface）
java語言使用關鍵字interface定義一個接口。接口也是抽象對象，它甚至比抽象類更抽象。接口中的方法都是抽象方法。
    一個接口可以繼承其他接口；一個類通過關鍵字implements聲明要實現一個接口，并具體實現接口的方法。
           例如：有一個接口InterfaceA，
           public interface InterfaceA {
                   void methodA();
           }
           類ClassA實現接口InterfaceA。
           public class ClassA {
                   public void methodA() {
                           System.out.println("methodA of ClassA implements InterfaceA");
                   }
           }
如果是抽象類實現一個接口，那么抽象類中可以不具體實現接口的方法（保持其抽象性），而由其子類去實現。
           抽象類ClassB實現接口InterfaceA，但是沒有具體實現方法methodA()，
           public abstract class ClassB {
           }
           子類ClassBSub實現接口InterfaceA，但是沒有具體實現方法methodA()，
           public class ClassBSub {
                   public void methodA() {
                           System.out.println("methodA of ClassBSub the subclass of ClassB");
                   }
           }
接口和抽象類顯著的共同點是接口和抽象類都可以有抽象方法。
接口和抽象類的不同點有：
           (1)抽象類可以有實例變量，而接口不能擁有實例變量，接口中的變量都是靜態（static）的常量（final）。
           (2)抽象類可以有非抽象方法，而接口只能有抽象方法。
java中，類與類之間是不能多繼承的。java之所以禁止類與類之間的多繼承是因為多繼承有很大的缺點。
多繼承雖然能使子類同時擁有多個父類的特征，但是其缺點也是很顯著的，主要有兩方面：
(1)如果在一個子類繼承的多個父類中擁有相同名字的實例變量，子類在引用該變量時將產生歧義，無法判斷應該使用哪個父類的變量。例如：
           類ClassA：
           public class ClassA {
                   protected int varSame = 0;
           }
           類ClassB：
           public class ClassB {
                   protected int varSame = 1;
           }
           子類ClassC：（假設允許類與類之間多繼承）
           public class ClassC extends ClassA, ClassB {
                   public void printOut() {
                           System.out.println(super.varSame);
                   }
                   public static void main(String[] args) {
                           ClassC classC = new ClassC();
                           classC.printOut();
                   }
           }
           上面程序的運行結果會是什么呢？輸出0還是1？
(2)如果在一個子類繼承的多個父類中擁有相同方法，子類中有沒有覆蓋該方法，那么調用該方法時將產生歧義，無法判斷應該調用哪個父類的方法。例如：
           類ClassA：
           public class ClassA {
                   public void printOut() {
                           System.out.println(0);
                   }
           }
           類ClassB：
           public class ClassB {
                   public void printOut() {
                           System.out.println(1);
                   }
           }
           子類ClassC：（假設允許類與類之間多繼承）
           public class ClassC extends ClassA, ClassB {
                   public static void main(String[] args) {
                           ClassA classA = new ClassC();
                           classA.printOut();       -------------------------  A行
                           ClassB classB = new ClassC();
                           classB.printOut();       -------------------------  B行
                           ClassC classC = new ClassC();
                           classC.printOut();       -------------------------  C行
                   }
           }
           上面程序的運行結果會是什么呢？A、B、C三行的輸出是0還是1？
正因為有以上的致命缺點，所以java中禁止一個類繼承多個父類；但是幸運的是java提供了接口，并能通過接口的功能獲得多繼承的許多優點而又摒棄了類與類多繼承的缺點。
java允許一個接口繼承多個父接口，也允許一個類實現多個接口，而這樣的多繼承有上面提到的缺點馬？
答案是沒有，這是由接口的抽象性決定的。
正如前面介紹的，在接口中不能有實例變量，只能有靜態的常量，不能有具體的方法（包含方法體），只能有抽象方法，因此也就摒棄了多繼承的缺點。
對于一個類實現多個接口的情況，因為接口只有抽象方法，具體方法只能由實現接口的類實現，在調用的時候始終只會調用實現類的方法（不存在歧義），因此不存在多繼承的第二個缺點；而又因為接口只有靜態的常量，但是由于靜態變量是在編譯期決定調用關系的，即使存在一定的沖突也會在編譯時提示出錯；而引用靜態變量一般直接使用類名或接口名，從而避免產生歧義，因此也不存在多繼承的第一個缺點。
對于一個接口繼承多個父接口的情況也一樣不存在這些缺點。
請看以下示例。
            接口A：
            public interface InterfaceA {
                    int len = 1;
                    void output();
            }
            接口B：
            public interface InterfaceB {
                    int len = 2;
                    void output();
            }
            接口Sub繼承接口A和接口B：
            public interface InterfaceSub extends InterfaceA, interfaceB {
            }
            類Xyz實現接口Sub：
            public class Xyz implements InterfaceSub {
                    public void output() {
                            System.out.println("output in class Xyz.");
                    }
                     public void outputLen(int type) {
                             switch(type) {
                                     case InterfaceA.len:
                                             System.out.println("len of InterfaceA=."+type);
                                             break;
                                     case InterfaceB.len:
                                             System.out.println("len of InterfaceB=."+type);
                                             break;
                             }
                    }
                   public static void main(String[] args) {
                           Xyz xyz= new Xyz ();
                           xyz .output();
                           xyz .outputLen();
                   }
           }
           以上代碼不存在什么問題，但是如果試圖編寫以下存在沖突的代碼，則會編譯失敗。
           Xyz xyz = new Xyz();
           int len = xyz.len;
           System.out.println(len);
由于引入了接口，java顯得非常靈活，也使得java中的多態性更加富有魔力。