C语言PostgreSQL学习手册(常用数据类型)

相同、数值类:

    下面是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版本被,decimalnumeric凡是同的。
    
    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类型创建的队在那所属字段被删去时,该队也用吃机关删除,但是其他情况下是不会见给剔除的。因此,如果你想就此和一个队列发生器同时深受几个字段提供数据,那么即便相应以单身对象的方法创造该队发生器。 

其次、字符类型:

    下面是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。
    
其三、日期/时间项目:

    下面是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)

季、布尔品种:

    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)
    
五、位串类型:

  
 位串就是一致弄错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)

六、数组:

    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条件才建。

七、复合类型:

  
 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);
  

    该篇博客是本着PostgreSQL官方文档中“数据类型”章节的略概括,这里用用相同首独立的博客来专门介绍,不仅是为系统学习,也造福今后欲时之迅速翻。

转自:http://www.cnblogs.com/stephen-liu74/archive/2012/04/30/2293602.html