你的操作系统是64位的，并且安装的是64位的PostgreSQL，而你的VS2013项目设置的目标平台是Win32的吧。所以，编辑时会发生那些符号链接错误。
福州网站制作公司哪家好，找创新互联建站！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。创新互联建站2013年至今到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联建站。
解决的方法有两种:
1) 将编辑的目标平台改为X64
2) 使用32位的PostgreSQL库(即使用32位的libpq.lib)
在oracle中sequence就是所谓的序列号，每次取的时候它会自动增加，一般用在需要按序列号排序的地方。 1、Create Sequence 你首先要有CREATE SEQUENCE或者CREATE ANY SEQUENCE权限， CREATE SEQUENCE emp_sequence INCREMENT BY 1 -- 每次加几个 START WITH 1 -- 从1开始计数 NOMAXVALUE -- 不设置最大值 NOCYCLE -- 一直累加，不循环 CACHE 10; 一旦定义了emp_sequence，你就可以用CURRVAL，NEXTVAL CURRVAL=返回 sequence的当前值 NEXTVAL=增加sequence的值，然后返回 sequence 值 比如： emp_sequence.CURRVAL emp_sequence.NEXTVAL 可以使用sequence的地方： - 不包含子查询、snapshot、VIEW的 SELECT 语句 - INSERT语句的子查询中 - NSERT语句的VALUES中 - UPDATE 的 SET中 可以看如下例子： INSERT INTO emp VALUES (empseq.nextval, 'LEWIS', 'CLERK',7902, SYSDATE, 1200, NULL, 20); SELECT empseq.currval FROM DUAL; 但是要注意的是： - 第一次NEXTVAL返回的是初始值；随后的NEXTVAL会自动增加你定义的INCREMENT BY值，然后返回增加后的值。CURRVAL 总是返回当前SEQUENCE的值，但是在第一次NEXTVAL初始化之后才能使用CURRVAL，否则会出错。一次NEXTVAL会增加一次SEQUENCE的值，所以如果你在同一个语句里面使用多个NEXTVAL，其值就是不一样的。明白？ - 如果指定CACHE值，ORACLE就可以预先在内存里面放置一些sequence，这样存取的快些。cache里面的取完后，oracle自动再取一组到cache。 使用cache或许会跳号， 比如数据库突然不正常down掉（shutdown abort),cache中的sequence就会丢失. 所以可以在create sequence的时候用nocache防止这种情况。 2、Alter Sequence 你或者是该sequence的owner，或者有ALTER ANY SEQUENCE 权限才能改动sequence. 可以alter除start至以外的所有sequence参数.如果想要改变start值，必须 drop sequence 再 re-create . Alter sequence 的例子 ALTER SEQUENCE emp_sequence INCREMENT BY 10 MAXVALUE 10000 CYCLE -- 到10000后从头开始 NOCACHE ; 影响Sequence的初始化参数： SEQUENCE_CACHE_ENTRIES =设置能同时被cache的sequence数目。 可以很简单的Drop Sequence DROP SEQUENCE order_seq; 示例Sequence： CREATE SEQUENCE SCOTT.DMIFPOSTID START WITH 261 INCREMENT BY 1 NOMINVALUE NOMAXVALUE NOCYCLE CACHE 20 NOORDER 3、如何使用 第一种方法：一般来说需要新建一个触发器（TRIGGER），使得在插入数据之前先运行Sequence生成自增号。示例Trigger -- Create table create table TEST ( SEQ INTEGER not null, NAME VARCHAR2(20), PWD VARCHAR2(20) ) tablespace USERS pctfree 10 initrans 1 maxtrans 255 storage ( initial 64K minextents 1 maxextents unlimited ); -- Create/Recreate primary, unique and foreign key constraints alter table TEST add constraint PK_TEST primary key (SEQ) using index tablespace USERS pctfree 10 initrans 2 maxtrans 255 storage ( initial 64K minextents 1 maxextents unlimited ); create or replace trigger TI_TEST before insert on test for each row declare -- local variables here begin SELECT SEQ_TEST.NEXTVAL INTO :NEW.SEQ FROM DUAL; end TI_TEST; 插入语句 insert into test values('aa','aa'); 第二种方法：可以在插入数据时直接调用。 insert into table(id,name) values(seq_name.nextval,'名字');
postgresql支持数组类型，可以是基本类型，也可以是用户自定义的类型。日常中使用数组类型的机会不多，但还是可以了解一下。不像C或JAVA高级语言的数组下标从0开始，postgresql数组下标从1开始，既可以指定长度，也可以不指定长度。且postgresql既支持一维数组，也支持多维数组，但是平时二维数组也就够用了。
示例1.使用ARRAY构建数组类型
---1*4的一维数组test=#selectarray[1,2,3,4];
array -----------{1,2,3,4}
(1 row)--2*2的二维数组test=#selectarray[[1,2],[3,4]];
array ---------------{{1,2},{3,4}}
(1 row)--1*2的二维数组，基本类型为box矩形类型，且和上面相比box类型元素之间是以分号分隔的，其他所有类型的数据都是以逗号分隔的test=#selectarray[box'(1,1),(0,0)',box'(0,0),(-1,-1)'];
array -----------------------------{(1,1),(0,0);(0,0),(-1,-1)}
(1row)
示例2.创建一张表，字段包含数组类型
其中int[]表示数组长度无限制，int[4]表示数组长度为4.
test=#createtabletbl_array(aint[],bvarchar(32)[][],cint);CREATETABLEtest=#insertintotbl_array (a,b,c)values(array[1,2],array[[1,2,3],[4,5,6]],1);INSERT01test=#insertintotbl_array (a,b,c)values(array[1,2,3],array[[1,2],[4,5]],2);INSERT01test=#select*from tbl_array ;
a |b| c ---------+-------------------+---{1,2}|{{1,2,3},{4,5,6}}|1 {1,2,3}|{{1,2},{4,5}}|2(2 rows)
test=#selecta[1],b[2]fromtbl_arraywherec=1;
a | b ---+---1|
(1 row)
test=#selecta[1],b[2][1]fromtbl_arraywherec=1;
a | b ---+---1|4(1 row)
test=#selecta[1],b[2][4]fromtbl_arraywherec=1;
a | b ---+---1|
(1row)
test=#updatetbl_arrayseta[1]=200wherea[1]=1;UPDATE1test=#selecta[1],b[2][4]from tbl_array ;
a | b -----+---100|200|
(2rows)
也可以使用[下标:上标]方式来查询数组连续的某些元素。
test=#selecta[2:3]from tbl_array ;
a -------{2}
{2,3}
(2 rows)
test=#selecta[1:3]from tbl_array ;
a -----------{100,2}
{200,2,3}
(2rows)
数组操作符与函数
操作符
操作符描述示例结果
=相等 SELECT ARRAY[1.1,2.1,3.1]::int[] = ARRAY[1,2,3]; t
不等于 select ARRAY[1,2,3] ARRAY[1,2,4]; t
小于 select ARRAY[1,2,3] ARRAY[1,2,4]; t
大于 select ARRAY[1,4,3] ARRAY[1,2,4]; t
=小于或等于 select ARRAY[1,2,3] = ARRAY[1,2,3]; t
=大于或等于 select ARRAY[1,4,3] = ARRAY[1,4,3]; t
@包含 select ARRAY[1,4,3] @ ARRAY[3,1]; t
@包含于 select ARRAY[2,7] @ ARRAY[1,7,4,2,6]; t
重叠（是否有相同元素） select ARRAY[1,4,3] ARRAY[2,1]; t
||数组与数组连接 select ARRAY[1,2,3] || ARRAY[4,5,6]; {1,2,3,4,5,6}
||数组与数组连接 select ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9]]; {{1,2,3},{4,5,6},{7,8,9}}
||元素与数组连接 select 3 || ARRAY[4,5,6]; {3,4,5,6}
||数组与元素连接 select ARRAY[4,5,6] || 7; {4,5,6,7}
函数
函数返回类型描述示例结果
array_append(anyarray,anyelement)anyarray 在数组末尾追加元素
SELECT array_append(ARRAY[1,2], 3);
{1,2,3}
array_cat(anyarray,anyarray)anyarray 连接两个数组 SELECT array_cat(ARRAY[1,2,3], ARRAY[4,5]); {1,2,3,4,5}
array_ndims(anyarray)int 返回数组维数 SELECT array_ndims(ARRAY[[1,2,3], [4,5,6]]); 2
array_dims(anyarray)text 返回数组维数的文本表示 SELECT array_dims(ARRAY[[1,2,3], [4,5,6]]); [1:2][1:3]
array_fill(anyelement,int[], [,int[]])anyarray使用提供的值和维度初始化一个数组，其中anyelement是值，第一个int[]是数组的长度，第二个int[]是数组下界，下界默认是1 SELECT array_fill(7, ARRAY[3], ARRAY[2]); [2:4]={7,7,7}
array_length(anyarray,int)int 返回数组指定维度的长度 SELECT array_length(array[1,2,3], 1); 3
array_lower(anyarray,int)int 返回数组指定维度的下界 SELECT array_lower('[0:2]={1,2,3}'::int[], 1); 0
array_position(anyarray,anyelement[,int])int 返回数组元素anyelement从数组的[,int]位置（默认为1）开始第一次出现在数组中的位置，数组必须是一维的 SELECT array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'mon'); 2
array_positions(anyarray,anyelement)int[] 返回元素在数组中的所有位置 SELECT array_positions(ARRAY['A','A','B','A'], 'A'); {1,2,4}
array_prepend(anyelement,anyarray)anyarray 在数组开头添加新的元素 SELECT array_prepend(1, ARRAY[2,3]); {1,2,3}
array_remove(anyarray,anyelement)anyarray 从数组中删除所有的指定元素，必须是一维数组 SELECT array_remove(ARRAY[1,2,3,2], 2); {1,3}
array_replace(anyarray,anyelement,anyelement)anyarray 替换指定数组元素为新的元素 SELECT array_replace(ARRAY[1,2,5,4], 5, 3); {1,2,3,4}
array_to_string(anyarray,text[,text])text 将数组元素使用分隔符连接为文本，NULL可以使用指定元素替换 SELECT array_to_string(ARRAY[1, 2, 3, NULL, 5], ',', '*'); 1,2,3,*,5
array_upper(anyarray,int)int 数组指定维度的上届 SELECT array_upper(ARRAY[1,8,3,7], 1); 4
cardinality(anyarray)int 返回数组所有维度的长度总和，如果是空数组则返回0 SELECT cardinality(ARRAY[[1,2],[3,4]]); 4
string_to_array(text,text[,text])text[] 将文本使用分隔符分隔后转换为数组，如果指定第三个参数，则第三个参数在数组中被转换为NULL SELECT string_to_array('xx~^~yy~^~zz', '~^~', 'yy'); {xx,NULL,zz}
unnest(anyarray)setof anyelement 将数组元素转换为行 SELECT unnest(ARRAY[1,2]);
1
2
unnest(anyarray,anyarray[, ...])setof anyelement, anyelement [, ...] 将多维数组转换为行集合，其中第一个数组显示为第一列，第二个数组显示为第二列，以此类推。但是这个函数只在from子句中使用 SELECT * from unnest(ARRAY[1,2],ARRAY['foo','bar','baz']);
unnest | unnest
--------+----
1 | foo
2 | bar
| baz
chcp是显示或设置活动代码页编号的程序。
首先你的系统是不是精简版的那些什么ghost版系统
如果不是，要以管理员身份运行postgresql
另外也可以去 C:\windows\system32 看看有没有 chcp.com
一、索引的类型：
PostgreSQL提供了多种索引类型：B-Tree、Hash、GiST和GIN，由于它们使用了不同的算法，因此每种索引类型都有其适合的查询类型，缺省时，CREATE INDEX命令将创建B-Tree索引。
1. B-Tree:
CREATE TABLE test1 (
id integer,
content varchar
);
CREATE INDEX test1_id_index ON test1 (id);
B-Tree索引主要用于等于和范围查询，特别是当索引列包含操作符" 、=和"作为查询条件时，PostgreSQL的查询规划器都会考虑使用B-Tree索引。在使用BETWEEN、IN、IS NULL和IS NOT NULL的查询中，PostgreSQL也可以使用B-Tree索引。然而对于基于模式匹配操作符的查询，如LIKE、ILIKE、~和 ~*，仅当模式存在一个常量，且该常量位于模式字符串的开头时，如col LIKE 'foo%'或col ~ '^foo'，索引才会生效，否则将会执行全表扫描，如：col LIKE '%bar'。
2. Hash：
CREATE INDEX name ON table USING hash (column);
散列(Hash)索引只能处理简单的等于比较。当索引列使用等于操作符进行比较时，查询规划器会考虑使用散列索引。
这里需要额外说明的是，PostgreSQL散列索引的性能不比B-Tree索引强，但是散列索引的尺寸和构造时间则更差。另外，由于散列索引操作目前没有记录WAL日志，因此一旦发生了数据库崩溃，我们将不得不用REINDEX重建散列索引。
3. GiST：
GiST索引不是一种单独的索引类型，而是一种架构，可以在该架构上实现很多不同的索引策略。从而可以使GiST索引根据不同的索引策略，而使用特定的操作符类型。
4. GIN：
GIN索引是反转索引，它可以处理包含多个键的值(比如数组)。与GiST类似，GIN同样支持用户定义的索引策略，从而可以使GIN索引根据不同的索引策略，而使用特定的操作符类型。作为示例，PostgreSQL的标准发布中包含了用于一维数组的GIN操作符类型，如：、=、等。
二、复合索引：
PostgreSQL中的索引可以定义在数据表的多个字段上，如：
CREATE TABLE test2 (
major int,
minor int,
name varchar
}
CREATE INDEX test2_mm_idx ON test2 (major, minor);
1. B-Tree类型的复合索引：
在B-Tree类型的复合索引中，该索引字段的任意子集均可用于查询条件，不过，只有当复合索引中的第一个索引字段(最左边)被包含其中时，才可以获得最高效率。
2. GiST类型的复合索引：
在GiST类型的复合索引中，只有当第一个索引字段被包含在查询条件中时，才能决定该查询会扫描多少索引数据，而其他索引字段上的条件只是会限制索引返回的条目。假如第一个索引字段上的大多数数据都有相同的键值，那么此时应用GiST索引就会比较低效。
3. GIN类型的复合索引：
与B-Tree和GiST索引不同的是，GIN复合索引不会受到查询条件中使用了哪些索引字段子集的影响，无论是哪种组合，都会得到相同的效率。
使用复合索引应该谨慎。在大多数情况下，单一字段上的索引就已经足够了，并且还节约时间和空间。除非表的使用模式非常固定，否则超过三个字段的索引几乎没什么用处。
三、组合多个索引：
PostgreSQL可以在查询时组合多个索引(包括同一索引的多次使用)，来处理单个索引扫描不能实现的场合。与此同时，系统还可以在多个索引扫描之间组成AND和OR的条件。比如，一个类似WHERE x = 42 OR x = 47 OR x = 53 OR x = 99的查询，可以被分解成四个独立的基于x字段索引的扫描，每个扫描使用一个查询子句，之后再将这些扫描结果OR在一起并生成最终的结果。另外一个例子是，如果我们在x和y上分别存在独立的索引，那么一个类似WHERE x = 5 AND y = 6的查询，就会分别基于这两个字段的索引进行扫描，之后再将各自扫描的结果进行AND操作并生成最终的结果行。
为了组合多个索引，系统扫描每个需要的索引，然后在内存里组织一个BITMAP，它将给出索引扫描出的数据在数据表中的物理位置。然后，再根据查询的需要，把这些位图进行AND或者OR的操作并得出最终的BITMAP。最后，检索数据表并返回数据行。表的数据行是按照物理顺序进行访问的，因为这是位图的布局，这就意味着任何原来的索引的排序都将消失。如果查询中有ORDER BY子句，那么还将会有一个额外的排序步骤。因为这个原因，以及每个额外的索引扫描都会增加额外的时间，这样规划器有时候就会选择使用简单的索引扫描，即使有多个索引可用也会如此。
四、唯一索引：
CREATE UNIQUE INDEX name ON table (column [, ...]);
五、表达式索引：
表达式索引主要用于在查询条件中存在基于某个字段的函数或表达式的结果与其他值进行比较的情况，如：
SELECT * FROM test1 WHERE lower(col1) = 'value';
此时，如果我们仅仅是在col1字段上建立索引，那么该查询在执行时一定不会使用该索引，而是直接进行全表扫描。如果该表的数据量较大，那么执行该查询也将会需要很长时间。解决该问题的办法非常简单，在test1表上建立基于col1字段的表达式索引，如：
CREATE INDEX test1_lower_col1_idx ON test1 (lower(col1));
SELECT * FROM people WHERE (first_name || ' ' || last_name) = 'John Smith';
和上面的例子一样，尽管我们可能会为first_name和last_name分别创建独立索引，或者是基于这两个字段的复合索引，在执行该查询语句时，这些索引均不会被使用，该查询能够使用的索引只有我们下面创建的表达式索引。
CREATE INDEX people_names ON people ((first_name || ' ' || last_name));
CREATE INDEX命令的语法通常要求在索引表达式周围书写圆括弧，就像我们在第二个例子里显示的那样。如果表达式只是一个函数调用，那么可以省略，就像我们在第一个例子里显示的那样。
从索引维护的角度来看，索引表达式要相对低效一些，因为在插入数据或者更新数据的时候，都必须为该行计算表达式的结果，并将该结果直接存储到索引里。然而在查询时，PostgreSQL就会把它们看做WHERE idxcol = 'constant'，因此搜索的速度等效于基于简单索引的查询。通常而言，我们只是应该在检索速度比插入和更新速度更重要的场景下使用表达式索引。
六、部分索引：
部分索引(partial index)是建立在一个表的子集上的索引，而该子集是由一个条件表达式定义的(叫做部分索引的谓词)。该索引只包含表中那些满足这个谓词的行。
由于不是在所有的情况下都需要更新索引，因此部分索引会提高数据插入和数据更新的效率。然而又因为部分索引比普通索引要小，因此可以更好的提高确实需要索引部分的查询效率。见以下三个示例：
1. 索引字段和谓词条件字段一致：
CREATE INDEX access_log_client_ip_ix ON access_log(client_ip)
WHERE NOT (client_ip inet '192.168.100.0' AND client_ip inet '192.168.100.255');
下面的查询将会用到该部分索引：
SELECT * FROM access_log WHERE url = '/index.html' AND client_ip = inet '212.78.10.32';
下面的查询将不会用该部分索引：
一个不能使用这个索引的查询可以是
SELECT * FROM access_log WHERE client_ip = inet '192.168.100.23';
2. 索引字段和谓词条件字段不一致：
PostgreSQL支持带任意谓词的部分索引，唯一的约束是谓词的字段也要来自于同样的数据表。注意，如果你希望你的查询语句能够用到部分索引，那么就要求该查询语句的条件部分必须和部分索引的谓词完全匹配。 准确说，只有在PostgreSQL能够识别出该查询的WHERE条件在数学上涵盖了该索引的谓词时，这个部分索引才能被用于该查询。
CREATE INDEX orders_unbilled_index ON orders(order_nr) WHERE billed is not true;
下面的查询一定会用到该部分索引：
SELECT * FROM orders WHERE billed is not true AND order_nr 10000;
那么对于如下查询呢？
SELECT * FROM orders WHERE billed is not true AND amount 5000.00;
这个查询将不像上面那个查询这么高效，毕竟查询的条件语句中没有用到索引字段，然而查询条件"billed is not true"却和部分索引的谓词完全匹配，因此PostgreSQL将扫描整个索引。这样只有在索引数据相对较少的情况下，该查询才能更有效一些。
下面的查询将不会用到部分索引。
SELECT * FROM orders WHERE order_nr = 3501;
3. 数据表子集的唯一性约束：
CREATE TABLE tests (
subject text,
target text,
success boolean,
...
);
CREATE UNIQUE INDEX tests_success_constraint ON tests(subject, target) WHERE success;
该部分索引将只会对success字段值为true的数据进行唯一性约束。在实际的应用中，如果成功的数据较少，而不成功的数据较多时，该实现方法将会非常高效。
七、检查索引的使用：
见以下四条建议：
1. 总是先运行ANALYZE。
该命令将会收集表中数值分布状况的统计。在估算一个查询返回的行数时需要这个信息，而规划器则需要这个行数以便给每个可能的查询规划赋予真实的开销值。如果缺乏任何真实的统计信息，那么就会使用一些缺省数值，这样肯定是不准确的。因此，如果还没有运行ANALYZE就检查一个索引的使用状况，那将会是一次失败的检查。
2. 使用真实的数据做实验。
用测试数据填充数据表，那么该表的索引将只会基于测试数据来评估该如何使用索引，而不是对所有的数据都如此使用。比如从100000行中选1000行，规划器可能会考虑使用索引，那么如果从100行中选1行就很难说也会使用索引了。因为100行的数据很可能是存储在一个磁盘页面中，然而没有任何查询规划能比通过顺序访问一个磁盘页面更加高效了。与此同时，在模拟测试数据时也要注意，如果这些数据是非常相似的数据、完全随机的数据，或按照排序顺序插入的数据，都会令统计信息偏离实际数据应该具有的特征。
3. 如果索引没有得到使用，那么在测试中强制它的使用也许会有些价值。有一些运行时参数可以关闭各种各样的查询规划。
4. 强制使用索引用法将会导致两种可能：一是系统选择是正确的，使用索引实际上并不合适，二是查询计划的开销计算并不能反映现实情况。这样你就应该对使用和不使用索引的查询进行计时，这个时候EXPLAIN ANALYZE命令就很有用了。
postgresql 从json数组中提取json值，并分组，汇总
json数据
[java] view plain copy
{"os": "Android", "chn": "-1", "dan": 0, "sex": 0, "file": "lv_statistics", "time": "2017-01-23 16:47:54", "honor": 0, "chn_id": "-1", "is_pay": 0, "account": "-1", "role_id": -1, "battle_id": 1050, "game_time": 301, "role_name": "-1", "battle_name": "-1", "battle_type": 4, "lv_num_json": [{"lv": 8,"num": 1},{"lv": 9,"num": 10}]"}
[java] view plain copy
SELECT cont-'lv_num_json' FROM log_info WHERE file = 'lv_statisticsx'
[java] view plain copy
查询结果：[{"lv": 8, "num": 1}, {"lv": 9, "num": 10}]
[sql] view plain copy
--例子
select json_array_elements(lv_num_json)-'lv' lv,json_array_elements(lv_num_json)-'num' num from (
select '[{"lv": 8, "num": 1}, {"lv": 9, "num": 10}]'::json lv_num_json
)as t1
输出结果:
lv num
---------------------
8 1
9 10
-- json_array_elements :展开一个JSON数组的JSON值
SELECT json_array_elements((cont-'lv_num_json')::json)-'lv' lv,json_array_elements((cont-'lv_num_json')::json)-'num' num
FROM log_info WHERE file = 'lv_statisticsx'
-- 按等级分组，求总人数
select lv ,sum(num::int) from(
SELECT json_array_elements((cont-'lv_num_json')::json)-'lv' lv,json_array_elements((cont-'lv_num_json')::json)-'num' num
FROM log_info WHERE file = 'lv_statisticsx'
) t1 GROUP BY lv
输出结果:
lv num
---------------------
8 2
9 20
