PostgreSQL學習手冊(四) 經常使用數據類型

1、數值類型：
    下面是PostgreSQL所支持的數值類型的列表和簡單說明：

名字	存儲空間	描述	範圍
smallint	2 字節	小範圍整數	-32768 到 +32767
integer	4 字節	經常使用的整數	-2147483648 到 +2147483647
bigint	8 字節	大範圍的整數	-9223372036854775808 到 9223372036854775807
decimal	變長	用戶聲明精度，精確	無限制
numeric	變長	用戶聲明精度，精確	無限制
real	4 字節	變精度，不精確	6 位十進制數字精度
double	8 字節	變精度，不精確	15 位十進制數字精度
serial	4 字節	自增整數	1 到 +2147483647
bigserial	8 字節	大範圍的自增整數	1 到 9223372036854775807

   1. 整數類型：
    類型smallint、integer和bigint存儲各類範圍的所有是數字的數，也就是沒有小數部分的數字。試圖存儲超出範圍之外的數值將致使一個錯誤。經常使用的類型是integer，由於它提供了在範圍、存儲空間和性能之間的最佳平衡。通常只有在磁盤空間緊張的時候才使用smallint。而只有在 integer的範圍不夠的時候才使用bigint，由於前者(integer)絕對快得多。 

    2. 任意精度數值：
    類型numeric能夠存儲最多1000位精度的數字而且準確地進行計算。所以很是適合用於貨幣金額和其它要求計算準確的數量。不過，numeric類型上的算術運算比整數類型或者浮點數類型要慢不少。
    numeric字段的最大精度和最大比例都是能夠配置的。要聲明一個類型爲numeric的字段，你能夠用下面的語法：
    NUMERIC(precision,scale)
    好比數字23.5141的精度爲6，而刻度爲4。
    在目前的PostgreSQL版本中，decimal和numeric是等效的。
    
    3. 浮點數類型：
    數據類型real和double是不許確的、犧牲精度的數字類型。不許確意味着一些數值不能準確地轉換成內部格式而且是以近似的形式存儲的，所以存儲後再把數據打印出來可能顯示一些缺失。
    
   4. Serial(序號)類型：
    serial和bigserial類型不是真正的類型，只是爲在表中設置惟一標識作的概念上的便利。
    CREATE TABLE tablename (
        colname SERIAL
    );
    等價於
    CREATE SEQUENCE tablename_colname_seq;
    CREATE TABLE tablename(
        colname integer DEFAULT nextval('tablename_colname_seq') NOT NULL
    );
    這樣，咱們就建立了一個整數字段而且把它的缺省數值安排爲從一個序列發生器取值。應用了一個NOT NULL約束以確保空值不會被插入。在大多數狀況下你可能還但願附加一個UNIQUE或者PRIMARY KEY約束避免意外地插入重複的數值，但這個不是自動發生的。所以，若是你但願一個序列字段有一個惟一約束或者一個主鍵，那麼你如今必須聲明，就像其它數據類型同樣。
    還須要另外說明的是，一個serial類型建立的序列在其所屬字段被刪除時，該序列也將被自動刪除，可是其它狀況下是不會被刪除的。所以，若是你想用同一個序列發生器同時給幾個字段提供數據，那麼就應該以獨立對象的方式建立該序列發生器。 

2、字符類型：
    下面是PostgreSQL所支持的字符類型的列表和簡單說明：

名字	描述
varchar(n)	變長，有長度限制
char(n)	定長,不足補空白
text	變長，無長度限制

    SQL 定義了兩種基本的字符類型，varchar(n)和char(n)，這裏的n是一個正整數。兩種類型均可以存儲最多n個字符長的字串，試圖存儲更長的字串 到這些類型的字段裏會產生一個錯誤，除非超出長度的字符都是空白，這種狀況下該字串將被截斷爲最大長度。若是沒有長度聲明，char等於char(1)， 而varchar則能夠接受任何長度的字串。
    MyTest=> CREATE TABLE testtable(first_col varchar(2));
    CREATE TABLE
    MyTest=> INSERT INTO testtable VALUES('333');   --插入字符串的長度，超過其字段定義的長度，所以報錯。
    ERROR:  value too long for type character varying(2)
    --插入字符串中，超出字段定義長度的部分是空格，所以能夠插入，可是空白符被截斷。
    MyTest=> INSERT INTO testtable VALUES('33 ');   
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
     first_col
    -----------
     33
    (1 row)
    這裏須要注意的是，若是是將數值轉換成char(n)或者varchar(n)，那麼超長的數值將被截斷成n個字符，而不會拋出錯誤。
    MyTest=> select 1234::varchar(2);
     varchar
    ---------
     12
    (1 row)
    最後須要提示的是，這三種類型之間沒有性能差異，只不過是在使用char類型時增長了存儲尺寸。雖然在某些其它的數據庫系統裏，char(n)有必定的性能優點，但在PostgreSQL裏沒有。在大多數狀況下，應該使用text或者varchar。
    
3、日期/時間類型：
    下面是PostgreSQL所支持的日期/時間類型的列表和簡單說明：

名字	存儲空間	描述	最低值	最高值	分辨率
timestamp[無時區]	8字節	包括日期和時間	4713 BC	5874897AD	1毫秒/14位
timestamp[含時區]	8字節	日期和時間，帶時區	4713 BC	5874897AD	1毫秒/14位
interval	12字節	時間間隔	-178000000年	178000000年	1毫秒/14位
date	4字節	只用於日期	4713 BC	32767AD	1天
time[無時區]	8字節	只用於一日內時間	00:00:00	24:00:00	1毫秒/14位

    1. 日期/時間輸入:
    任何日期或者時間的文本輸入均須要由單引號包圍，就象一個文本字符串同樣。
    1). 日期:
    如下爲合法的日期格式列表：

例子	描述
January 8, 1999	在任何datestyle輸入模式下都無歧義
1999-01-08	ISO-8601格式，任何方式下都是1999年1月8號，(建議格式)
1/8/1999	歧義，在MDY下是1月8號；在 DMY模式下讀作8月1日
1/18/1999	在MDY模式下讀作1月18日，其它模式下被拒絕
01/02/03	MDY模式下的2003年1月2日；DMY模式下的2003年2月1日；YMD 模式下的2001年2月3日
1999-Jan-08	任何模式下都是1月8日
Jan-08-1999	任何模式下都是1月8日
08-Jan-1999	任何模式下都是1月8日
99-Jan-08	在YMD模式下是1月8日，不然錯誤
08-Jan-99	1月8日，除了在YMD模式下是錯誤的以外
Jan-08-99	1月8日，除了在YMD模式下是錯誤的以外
19990108	ISO-8601; 任何模式下都是1999年1月8日
990108	ISO-8601; 任何模式下都是1999年1月8日

    2). 時間：
    如下爲合法的時間格式列表：

例子	描述
04:05:06.789	ISO 8601
04:05:06	ISO 8601
04:05	ISO 8601
040506	ISO 8601
04:05 AM	與04:05同樣；AM不影響數值
04:05 PM	與16:05同樣；輸入小時數必須 <= 12
04:05:06.789-8	ISO 8601
04:05:06-08:00	ISO 8601
04:05-08:00	ISO 8601
040506-08	ISO 8601

    3). 時間戳：
    時間戳類型的有效輸入由一個日期和時間的聯接組成，後面跟着一個可選的時區。所以，1999-01-08 04:05:06和1999-01-08 04:05:06 -8:00都是有效的數值。
   
   2. 示例：
    1). 在插入數據以前先查看datestyle系統變量的值：
    MyTest=> show datestyle;
     DateStyle
    -----------
     ISO, YMD
    (1 row)
    2). 建立包含日期、時間和時間戳類型的示例表：
    MyTest=> CREATE TABLE testtable (id integer, date_col date, time_col time, timestamp_col timestamp);
    CREATE TABLE
    3). 插入數據：
    MyTest=> INSERT INTO testtable(id,date_col) VALUES(1, DATE'01/02/03');  --datestyle爲YMD
    INSERT 0 1
    MyTest=> SELECT id, date_col FROM testtable;
     id   |  date_col
    ----+------------
      1  | 2001-02-03
    (1 row)
    
    MyTest=> set datestyle = MDY;
    SET
    MyTest=> INSERT INTO testtable(id,date_col) VALUES(2, DATE'01/02/03');  --datestyle爲MDY
    INSERT 0 1
    MyTest=> SELECT id,date_col FROM testtable;
     id   |  date_col
    ----+------------
      1  | 2001-02-03
      2  | 2003-01-02  

    MyTest=> INSERT INTO testtable(id,time_col) VALUES(3, TIME'10:20:00');  --插入時間。
    INSERT 0 1
    MyTest=> SELECT id,time_col FROM testtable WHERE time_col IS NOT NULL;
     id   | time_col
    ----+----------
      3   | 10:20:00
    (1 row)

    MyTest=> INSERT INTO testtable(id,timestamp_col) VALUES(4, DATE'01/02/03'); 
    INSERT 0 1
    MyTest=> INSERT INTO testtable(id,timestamp_col) VALUES(5, TIMESTAMP'01/02/03 10:20:00');
    INSERT 0 1
    MyTest=> SELECT id,timestamp_col FROM testtable WHERE timestamp_col IS NOT NULL;
     id   |    timestamp_col
    ----+---------------------
      4  | 2003-01-02 00:00:00
      5  | 2003-01-02 10:20:00
    (2 rows)

4、布爾類型：
    PostgreSQL支持標準的SQL boolean數據類型。boolean只能有兩個狀態之一：真(True)或 假(False)。該類型佔用1個字節。
    "真"值的有效文本值是：
    TRUE
    't'
    'true'
    'y'
    'yes'
    '1'
    而對於"假"而言，你可使用下面這些：
    FALSE
    'f'
    'false'
    'n'
    'no'
    '0'
　 見以下使用方式：
    MyTest=> CREATE TABLE testtable (a boolean, b text);
    CREATE TABLE
    MyTest=> INSERT INTO testtable VALUES(TRUE, 'sic est');
    INSERT 0 1
    MyTest=> INSERT INTO testtable VALUES(FALSE, 'non est');
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
     a  |    b
    ---+---------
     t  | sic est
     f  | non est
    (2 rows)    
    MyTest=> SELECT * FROM testtable WHERE a;
     a  |    b
    ---+---------
     t  | sic est
    (1 row)    
    MyTest=> SELECT * FROM testtable WHERE a = true;
     a  |    b
    ---+---------
     t  | sic est
    (1 row)
    
5、位串類型：
    位串就是一串1和0的字串。它們能夠用於存儲和視覺化位掩碼。咱們有兩種類型的SQL位類型：bit(n)和bit varying(n); 這裏的n是一個正整數。bit類型的數據必須準確匹配長度n; 試圖存儲短些或者長一些的數據都是錯誤的。類型bit varying數據是最長n的變長類型；更長的串會被拒絕。寫一個沒有長度的bit等效於bit(1)，沒有長度的bit varying至關於沒有長度限制。
    針對該類型，最後須要提醒的是，若是咱們明確地把一個位串值轉換成bit(n)，那麼它的右邊將被截斷或者在右邊補齊零，直到恰好n位，而不會拋出任何錯誤。相似地，若是咱們明確地把一個位串數值轉換成bit varying(n)，若是它超過n位，那麼它的右邊將被截斷。 見以下具體使用方式：    
    MyTest=> CREATE TABLE testtable (a bit(3), b bit varying(5));
    CREATE TABLE
    MyTest=> INSERT INTO testtable VALUES (B'101', B'00');
    INSERT 0 1
    MyTest=> INSERT INTO testtable VALUES (B'10', B'101');
    ERROR:  bit string length 2 does not match type bit(3)
    MyTest=> INSERT INTO testtable VALUES (B'10'::bit(3), B'101');
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
      a  |  b
    -----+-----
     101 | 00
     100 | 101
    (2 rows)
    MyTest=> SELECT B'11'::bit(3);
     bit
    -----
     110
    (1 row)

6、數組：
    1. 數組類型聲明：
    1). 建立字段含有數組類型的表。
    CREATE TABLE sal_emp (
        name            text,
        pay_by_quarter  integer[] --還能夠定義爲integer[4]或integer ARRAY[4]
    );
    2). 插入數組數據：
    MyTest=# INSERT INTO sal_emp VALUES ('Bill', '{11000, 12000, 13000, 14000}');
    INSERT 0 1
    MyTest=# INSERT INTO sal_emp VALUES ('Carol', ARRAY[21000, 22000, 23000, 24000]);
    INSERT 0 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,14000}
     Carol  | {21000,22000,23000,24000}
    (2 rows)    

    2. 訪問數組：
    和其餘語言同樣，PostgreSQL中數組也是經過下標數字(寫在方括弧內)的方式進行訪問，只是PostgreSQL中數組元素的下標是從1開始n結束。
    MyTest=# SELECT pay_by_quarter[3] FROM sal_emp;
     pay_by_quarter
    ----------------
              13000
              23000
    (2 rows)
    MyTest=# SELECT name FROM sal_emp WHERE pay_by_quarter[1] <> pay_by_quarter[2];
     name
    ------
     Bill
     Carol
    (2 rows)
    PostgreSQL中還提供了訪問數組範圍的功能，即ARRAY[腳標下界:腳標上界]。
    MyTest=# SELECT name,pay_by_quarter[1:3] FROM sal_emp;
     name  |   pay_by_quarter
    --------+---------------------
     Bill     | {11000,12000,13000}
     Carol  | {21000,22000,23000}
    (2 rows)
    
    3. 修改數組：
    1). 代替所有數組值：
    --UPDATE sal_emp SET pay_by_quarter = ARRAY[25000,25000,27000,27000] WHERE name = 'Carol'; 也能夠。
    MyTest=# UPDATE sal_emp SET pay_by_quarter = '{31000,32000,33000,34000}' WHERE name = 'Carol';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,14000}
     Carol  | {31000,32000,33000,34000}
    (2 rows)
    2). 更新數組中某一元素：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[4] = 15000 WHERE name = 'Bill';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Carol  | {31000,32000,33000,34000}
     Bill     | {11000,12000,13000,15000}
    (2 rows)
    3). 更新數組某一範圍的元素：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[1:2] = '{37000,37000}' WHERE name = 'Carol';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,15000}
     Carol  | {37000,37000,33000,34000}
    (2 rows)
    4). 直接賦值擴大數組：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[5] = 45000 WHERE name = 'Bill';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |         pay_by_quarter
    --------+---------------------------------
     Carol  | {37000,37000,33000,34000}
     Bill     | {11000,12000,13000,15000,45000}
    (2 rows)

    4. 在數組中檢索：
    1). 最簡單直接的方法：
    SELECT * FROM sal_emp WHERE pay_by_quarter[1] = 10000 OR
                            pay_by_quarter[2] = 10000 OR
                            pay_by_quarter[3] = 10000 OR
                            pay_by_quarter[4] = 10000;    
    2). 更加有效的方法：
    SELECT * FROM sal_emp WHERE 10000 = ANY (pay_by_quarter); --數組元素中有任何一個等於10000，where條件將成立。
    SELECT * FROM sal_emp WHERE 10000 = ALL (pay_by_quarter); --只有當數組中全部的元素都等於10000時，where條件才成立。

7、複合類型：
    PostgreSQL 中複合類型有些相似於C語言中的結構體，也能夠被視爲Oracle中的記錄類型，可是仍是感受複合類型這個命名比較貼切。它實際上只是一個字段名和它們的數據類型的列表。PostgreSQL容許像簡單數據類型那樣使用複合類型。好比，表字段能夠聲明爲一個複合類型。
    1. 聲明覆合類型:
    下面是兩個簡單的聲明示例：
    CREATE TYPE complex AS (
        r double,
        i double
    );   
    CREATE TYPE inventory_item AS (
        name           text,
        supplier_id   integer,
        price            numeric
    );
    和聲明一個數據表相比，聲明類型時須要加AS關鍵字，同時在聲明TYPE時不能定義任何約束。下面咱們看一下如何在表中指定複合類型的字段，如：
    CREATE TABLE on_hand (
        item      inventory_item,
        count    integer
    );
    最後須要指出的是，在建立表的時候，PostgreSQL也會自動建立一個與該表對應的複合類型，名字與表字相同，即表示該表的複合類型。
    
    2. 複合類型值輸入：
    咱們可使用文本常量的方式表示複合類型值，即在圓括號裏包圍字段值而且用逗號分隔它們。你也能夠將任何字段值用雙引號括起，若是值自己包含逗號或者圓括號，那麼就用雙引號括起，對於上面的inventory_item複合類型的輸入以下：
    '("fuzzy dice",42,1.99)'
    若是但願類型中的某個字段爲NULL，只需在其對應的位置不予輸入便可，以下面的輸入中price字段的值爲NULL，
    '("fuzzy dice",42,)'
    若是隻是須要一個空字串，而非NULL，寫一對雙引號，如：
    '("",42,)'
    在更多的場合中PostgreSQL推薦使用ROW表達式來構建複合類型值，使用該種方式相對簡單，無需考慮更多標識字符問題，如：
    ROW('fuzzy dice', 42, 1.99)
    ROW('', 42, NULL)
    注：對於ROW表達式，若是裏面的字段數量超過1個，那麼關鍵字ROW就能夠省略，所以以上形式能夠簡化爲：
    ('fuzzy dice', 42, 1.99)
    ('', 42, NULL)
    
    3. 訪問複合類型：
    訪問複合類型中的字段和訪問數據表中的字段在形式上極爲類似，只是爲了對兩者加以區分，PostgreSQL設定在訪問複合類型中的字段時，類型部分須要用圓括號括起，以免混淆，如：
    SELECT (item).name FROM on_hand WHERE (item).price > 9.99;
    若是在查詢中也須要用到表名，那麼表名和類型名都須要被圓括號括起，如：
    SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;
    
    4. 修改複合類型：
    見以下幾個示例：
    --直接插入複合類型的數據，這裏是經過ROW表達式來完成的。
    INSERT INTO on_hand(item) VALUES(ROW("fuzzy dice",42,1.99));
    --在更新操做中，也是能夠經過ROW表達式來完成。
    UPDATE on_hand SET item = ROW("fuzzy dice",42,1.99) WHERE count = 0;
    --在更新複合類型中的一個字段時，咱們不能在SET後面出現的字段名周圍加圓括號，
    --可是在等號右邊的表達式裏引用同一個字段時卻須要圓括號。
    UPDATE on_hand SET item.price = (item).price + 1 WHERE count = 0;
    --能夠在插入中，直接插入複合類型中字段。
    INSERT INTO on_hand (item.supplier_id, item.price) VALUES(100, 2.2);