在postgreSQL 8.3自带支持全文检索功能，在之前的版本中需要安装配置tsearch2才能使用，安转配置tsearch2就不再多说了，主要介绍一下8.3中自带全文检索功能。

全文检索类型(Text Search Types)

postgreSQL设计支持全文检索，提供两个数据类型（tsvector,tsquery），并且通过动态检索自然语言文档的集合，定位到最匹配的查询结果。

tsvector

一个tsvector的值是唯一分词的分类列表，把一话一句词格式化为不同的词条，在进行分词处理的时候
tsvector会自动去掉分词中重复的词条，按照一定的顺序装入。例如

SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector;
                      tsvector
----------------------------------------------------
 'a' 'on' 'and' 'ate' 'cat' 'fat' 'mat' 'rat' 'sat'

从上面的例子可以看出 ，通过tsvector把一个字符串按照空格进行分词，分词的顺序是按照长短和字母来排序的。但是某些时候，我们为了让词条中包含空格或者符号，就需要对其使用引号。
SELECT $$the lexeme '    ' contains spaces$$::tsvector;
                 tsvector                 
-------------------------------------------
 'the' '    ' 'lexeme' 'spaces' 'contains'

为了使用引号，我们可以使用双$$符号来避免混淆。
并且词条位置常量可以附属于每个词条,例如：
SELECT 'a:1 fat:2 cat:3 sat:4 on:5 a:6 mat:7 and:8 ate:9 a:10 fat:11 rat:12'::tsvector;
                                  tsvector
-------------------------------------------------------------------------------
 'a':1,6,10 'on':5 'and':8 'ate':9 'cat':3 'fat':2,11 'mat':7 'rat':12 'sat':4

这个位置信息通常就是当前文档中单词所处的位置，这个位置信息用于关注度的体现。位置信息常量的值的范围为1 到 16383。分词后，会把相同词条的位置记录到一个词条中。（如上所示）。
词条通过权重可以使其所在位置促进它的标记。权重分为A,B,C,D,D为默认值可以不显示.

权重用于关系,体现文档结构是很有特色地.例如,通俗一点,就是相同的词条,但是词条所在位置的权重不一样,在一个文档中,标题和文本内容,在做全文检索排序功能时需要分配给这两个词不同的优先权,不同的权重标记.

理解tsvector类型是很重要的,不能只关注标准的应用.例如
select 'The Fat Rats'::tsvector;
      tsvector     
--------------------
 'Fat' 'The' 'Rats'
但是对于英文全文检索应用来说,上面的句子就是非标准化的,但是tsvector是不会知道的,为处理加工的文本应该通过使用to_tsvector函数来是之规格化,标注化的应用于搜索.

SELECT to_tsvector('english', 'The Fat Rats');        
   to_tsvector  
-----------------
 'fat':2 'rat':3

tsquery

顾名思义,tsquery,表示的应该是查询相关的.tsquery是存储用于检索的词条.并且可以联合使用boolean 操作符来连接, & (AND), | (OR), and ! (NOT). 使用括号(),可以强制分为一组.

 SELECT 'fat & rat'::tsquery;
    tsquery   
---------------
 'fat' & 'rat'

SELECT 'fat & (rat | cat)'::tsquery;
          tsquery         
---------------------------
 'fat' & ( 'rat' | 'cat' )

SELECT 'fat & rat & ! cat'::tsquery;
        tsquery        
------------------------
 'fat' & 'rat' & !'cat'
同时,tsquery 在做搜索的时候,也可以使用权重,并且每个词都可以使用一个或者多个权重标记,这样在检索的时候,会匹配相同权重的信息.
跟上面的tsvector ,相同tsquery也有一个to_tsquery函数.

全文检索的 document

document就是全文检索的搜索单元,在postgresql中全文检索匹配操作使用@@ 操作符,如果一个
tsvector(document) 匹配到 tsquery(query)则返回true.

SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector @@ 'cat & rat'::tsquery;
 ?column?
----------
 t
我们在处理索引的时候还是要使用他们的函数如,
SELECT to_tsvector('fat cats ate fat rats') @@ to_tsquery('fat & rat');
 ?column?
----------
 t
并且操作符 @@ 可以使用text作为tsvector和tsquery.如下操作符可以使使用的方法

tsvector @@ tsquery
tsquery  @@ tsvector
text @@ tsquery
text @@ text
上面的前两种我们已经使用过了,但是后两种,
text @@ tsquery 等同于 to_tsvector(x) @@ y.
而 text @@ text 等同于 to_tsvector(x) @@ plainto_tsquery(y).

表和索引

前面介绍了如何在简单文本中进行全文检索匹配.下面部分将介绍如何检索表数据和使用索引.

检索一个表

在全文检索中不使用索引也是可以进行检索的,例如下面的简单例子,查询出title 从所有body中包含friend的行.

SELECT title
FROM pgweb
WHERE to_tsvector('english', body) @@ to_tsquery('english', 'friend');

复杂一点的例子:
检索出最近的10个文档,在表中的title 和 body字段中包含 creat和table的titile.
SELECT title
FROM pgweb
WHERE to_tsvector(title || body) @@ to_tsquery('create & table')
ORDER BY last_mod_date DESC LIMIT 10;

建立索引

我们可以通过创建gin索引来加速检索速度.例如

CREATE INDEX pgweb_idx ON pgweb USING gin(to_tsvector('english', body));

创建索引可以有多种方式.索引的创建甚至可以连接两个列:
CREATE INDEX pgweb_idx ON pgweb USING gin(to_tsvector('english', title || body));
另外的一种方式是创建一个单独的 tsvector列,然后使用to_tsvector函数把需要索引字段的数据联合在一起，比如列title和body，并且使用函数coalesce来确保字段为NULL的可以建立索引。
如下：
ALTER TABLE pgweb ADD COLUMN textsearchable_index_col tsvector;
UPDATE pgweb SET textsearchable_index_col =
     to_tsvector('english', coalesce(title,'') || coalesce(body,''));
然后，我们就可以创建倒排的索引
CREATE INDEX textsearch_idx ON pgweb USING gin(textsearchable_index_col);
索引创建完毕，我们就可以使用全文检索了。
SELECT title
FROM pgweb
WHERE textsearchable_index_col @@ to_tsquery('create & table')
ORDER BY last_mod_date DESC LIMIT 10;

控制全文检索(Controlling Text Search)

为了实现全文检索，我们需要把一个文档创建一个tsvector 格式，并且通过tsquery实现用户的查询。
因此，在查询中我们返回一个按照重要性排序的查询结果。

分析文档(Parsing Documents)

postgresql 中提供了to_tsvector函数把文档处理成tsvector数据类型。（前面已经介绍过了）
这个函数会将文本文档，分解成唯一的词条，并且还包括词条所在文本中的位置。（这里to_tsvector函数就不再多做介绍了）。
其实在做分词是很重要的步骤，分词的操作直接关系到你的后来检索的结果。（后面再重要描述）
在postgreSQL中默认的to_tsvector（'english',）配置默认的是英语。
postgre 中还有一个函数 setweight ，要使用这个函数我们要引入一个概念，这个概念就是权重weight，什么是权重呢，字面上解释就是权衡一下哪个更重要，也就是说哪个更侧重一些。我们可以通过函数setweight来设置权重，postgre提供了四个A，B，C，D来分别表示不同权重级别，这个级别类型用来标记他们来自于文档中的不同部分，例如title和body。查询结果的关注度可以使用这个权重级别。如：
UPDATE tt SET ti =
    setweight(to_tsvector(coalesce(title,'')), 'A')    ||
    setweight(to_tsvector(coalesce(keyword,'')), 'B')  ||
    setweight(to_tsvector(coalesce(abstract,'')), 'C') ||
    setweight(to_tsvector(coalesce(body,'')), 'D');

搜索分析(Parsing Queries)

postgreSQL中提供了to_tsquery函数和plainto_tsquery函数，来处理分析搜索语句。

SELECT to_tsquery('english', 'The & Fat & Rats');
  to_tsquery  
---------------
 'fat' & 'rat'

在搜索中tsquery中可以使用权重（weight）,在搜索词条中可以附加权重，并且匹配出来的查询结果也是必须在这个这个权重范围的。

SELECT to_tsquery('english', 'Fat | Rats:AB');
    to_tsquery   
------------------
 'fat' | 'rat':AB

从上面的例子可以看出，to_tsquery函数在处理查询文本的时候，查询文本的单个词之间要使用逻辑操作符（& (AND), | (OR) and ! (NOT)）连接（或者使用括号）。例如 跟上面的例子相似

SELECT to_tsquery('english', 'Fat  Rats');

如果要使执行上面的操作，就会报语法错误。
然而plainto_tsquery函数却可以提供一个标准的tsquery，如上面的例子，plainto_tsquery会自动加上逻辑&操作符。
SELECT plainto_tsquery('english', 'Fat  Rats');

 plainto_tsquery
-----------------
 'fat' & 'rat'
但是plainto_tsquery函数不能够识别逻辑操作符和权重标记。
SELECT plainto_tsquery('english', 'The Fat & Rats:C');
   plainto_tsquery  
---------------------
 'fat' & 'rat' & 'c'

查询结果关注度(Ranking Search Results)

相关度，就是试图测试衡量哪一个文档是检索中最关注的。因此我们把最匹配的文档现在在最前面。这样才能真正达到检索的准确度，postgresql提供两个相关的函数，ts_rank和ts_rank_cd.
这两个函数的语法是
ts_rank([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ]) returns float4

ts_rank_cd([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ]) returns float4

两个函数的第一个参数都是 权重(weight)，在前面已经讲了权重的概念。
参数的格式为 {D-weight, C-weight, B-weight, A-weight} ，在使用函数的时候没有指定这个参数，postgre会默认指定参数为：{0.1, 0.2, 0.4, 1.0}
这个参数应该理解为：单前检索的关键词（词条）在当前这个检索文档中的位置，如果这个词条在这个当前的位置权重高，那么他的相关度的值也会高。
另外函数的最好一个参数是一个整型，这个参数是表示，这个参数指定文档大小影响相关度的程度。
你可以指定一个或者多个例如（2|4）。
这些参数的定义

0 (the default) ignores the document length
表示跟长度大小没有关系
1 divides the rank by 1 + the logarithm of the document length
表示参数 关注度（rank）除以 文档长度的对数+1
2 divides the rank by the document length
表示 关注度 除以 文档的长度
4 divides the rank by the mean harmonic distance between extents (this is implemented only by ts_rank_cd)
表示 关注度 除以 文档长度的平均值，只能使用函数ts_rank_cd.
8 divides the rank by the number of unique words in document
表示 关注度 除以 文档中 唯一分词的数量
16 divides the rank by 1 + the logarithm of the number of unique words in document
表示关注度 除以 唯一分词数量的对数+1
32 divides the rank by itself + 1
表示 关注度 除以 本身+1

其他的一些特性

       length(vector tsvector) returns integer
    这个函数返回当前索引字段的分词长度，就是分词的个数

       strip(vector tsvector) retzitor
这个函数返回当前索引字段的数据不包括词的位置

自动更新处理的触发器(Triggers for Automatic Updates)

在我们作全文检索的时候，当我们使用单独的列来存储索引文件的时候，我们一定需要创建一个触发器，当涉及索引字段的其他列的内容改变的时候，索引文件也要相应的改变，postgre提供两个触发器可以实现该功能，也可以自定义触发器。

这两个触发器的为：
    tsvector_update_trigger(tsvector_column_name, config_name, text_column_name [, ... ])
    tsvector_update_trigger_column(tsvector_column_name, config_column_name, text_column_name [, ... ])

这个函数可以自动把一个或者多个文本字段，计算生成索引字段。例如

我们创建一个表
CREATE TABLE messages (
    title       text,
    body        text,
    tsv         tsvector//索引字段
);

CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE
ON messages FOR EACH ROW EXECUTE PROCEDURE
tsvector_update_trigger(tsv, 'pg_catalog.english', title, body);
创建触发器，字段title和body都是文本字段，他们索引后的字段为tsv,这里使用postgre自带的分词规则pg_catalog.english。
向表中插入一条数据。
INSERT INTO messages VALUES('title here', 'the body text is here');

SELECT * FROM messages;
   title    |         body          |            tsv            
------------+-----------------------+----------------------------
 title here | the body text is here | 'bodi':4 'text':5 'titl':1
可以看到tsv字段自动加入的数据，并且经过tsvector处理。
接下来我们测试一下检索
SELECT title, body FROM messages WHERE tsv @@ to_tsquery('title & body');
上面这个查询，查不到结果。
SELECT title, body FROM messages WHERE tsv @@ to_tsquery('english','title & body');
   title    |         body         
------------+-----------------------
 title here | the body text is here
注意: 看上面的查询条件，在进行全文检索的时候，在创建索引时，使用的分词方式，与检索时使用的分词方式一定要想同，否则查询的结果就会有问题。

创建触发器后，不论title或者body那个字段改变，都会自动反射给tsv,索引会自动更新。

上面这中自带的触发器很有局限性，比如说，在建立索引的时候title和body要有不同的权重，上面的触发器就能达到我们想要的效果，下面是一个 pl/pgsql 触发器。

CREATE FUNCTION messages_trigger() RETURNS trigger AS $$
begin
  new.tsv :=
     setweight(to_tsvector('pg_catalog.english', coalesce(new.title,'')), 'A') ||
     setweight(to_tsvector('pg_catalog.english', coalesce(new.body,'')), 'D');
  return new;
end
$$ LANGUAGE plpgsql;

CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE
ON messages FOR EACH ROW EXECUTE PROCEDURE messages_trigger();

索引统计函数

 ts_stat(sqlquery text, [ weights text, ] OUT word text, OUT ndoc integer, OUT nentry integer)

返回的是统计的纪录

word text — 索引中的词条

ndoc integer — 词条在索引中出现的次数

nentry integer — 词条在文档中出现的总次数

例如：

SELECT * FROM ts_stat('SELECT tsv FROM messages')
ORDER BY nentry DESC, ndoc DESC, word
LIMIT 10;

查询的结果为

  word     ndoc  nentry

  test     2      3
  title    2      2
  test     1      2
  body     1      1

上面可以看到，通过ts_stat函数就可以看到索引列中的分词的情况。

词典(Dictionaries)

词典就是被用来过滤掉一些不被关注的词（在检索的时候），并且对词句规格化，是为了相同的词在不同的来源的文档中可以被匹配。一个成功分词（格式化的）的词称为词条。除了能提高检索的质量外，分词的规格化，过滤词，还能够减少文档索引的大小，这样可以提高性能。标准化的词也不能总是符合语言学意义，并且总是依赖于应用所在的环境。
简单举例：
例如一些颜色名称，将会被替换成其相对应的16进制的值，如 red,green,blue ->FF0000, 00FF00, 0000FF 等。
如果要制定小数，我们可以去掉一些小数的位数，来减少范围。如 3.14159265359 ,3.1415926,这两个小数如果是保留小数点后两位小数，那么格式化后他们的值将都是 3.14。

postgresql提供了一些预定义的词典面向多种语言的，并且还有几个预定义的模版，可以根据用户的需要自定义词典。

屏蔽词(Stop Words)
stop words 是一个很普遍并且在每个文档中几乎都能出现的的词，并且这个词没有实际的意义，因此在全文检索的文档中他么将被忽略。例如 英文文本内容中单词 像 a 和like，他们不需要存储在索引中，但是他会影响词所在文档的位置。
SELECT to_tsvector('english','in the list of stop words');
        to_tsvector
----------------------------
 'list':3 'stop':5 'word':6
并且相关度的计算与是否存在stop words是十分不同的,如:
SELECT ts_rank_cd (to_tsvector('english','in the list of stop words'), to_tsquery('list & stop'));
 ts_rank_cd
------------
       0.05

SELECT ts_rank_cd (to_tsvector('english','list stop words'), to_tsquery('list & stop'));
 ts_rank_cd
------------
        0.1

简单词典

使用简单词典,自定义词典,如:

CREATE TEXT SEARCH DICTIONARY public.simple_dict (
    TEMPLATE = pg_catalog.simple,
    STOPWORDS = english
);

上面例子中的 english是表示的stop words的名字,这个stop words的全名因该是$sharedir/tsearch_data/english.stop,$sharedir也就是postgresql的安装目录下.现在我们使用一下新建的词典.如:
SELECT ts_lexize('public.simple_dict','YeS');
 ts_lexize
-----------
 {yes}

SELECT ts_lexize('public.simple_dict','The');
 ts_lexize
-----------
 {}
还有几个postgresql中自带的词典, Simple Dictionary,Synonym Dictionary
,Thesaurus Dictionary
,Ispell Dictionary
,Snowball Dictionary
这里不再详细介绍了.

全文检索的测试和调试

ts_debug函数用来调试全文检索的

这个函数显示的是文档的每个词条通过基本词典的分析和处理的信息。
这个函数返回的信息为：
alias text — short name of the token type
文本别名-词的类型名称
description text — description of the token type
描述-描述词的类型
token text — text of the token
词内容-词的文本内容
dictionaries regdictionary[] — the dictionaries selected by the configuration for this token type
词典-词的配置所选择的词典
dictionary regdictionary — the dictionary that recognized the token, or NULL if none did
词典
lexemes text[] — the lexeme(s) produced by the dictionary that recognized the token, or NULL if none did; an empty array ({}) means it was recognized as a stop word
处理后的词条

Here is a simple example:

SELECT * FROM ts_debug('english','a fat  cat sat on a mat - it ate a fat rats');
   alias   |   description   | token |  dictionaries  |  dictionary  | lexemes
-----------+-----------------+-------+----------------+--------------+---------
 asciiword | Word, all ASCII | a     | {english_stem} | english_stem | {}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | fat   | {english_stem} | english_stem | {fat}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | cat   | {english_stem} | english_stem | {cat}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | sat   | {english_stem} | english_stem | {sat}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | on    | {english_stem} | english_stem | {}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | a     | {english_stem} | english_stem | {}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | mat   | {english_stem} | english_stem | {mat}
 blank     | Space symbols   |       | {}             |              |
 blank     | Space symbols   | -     | {}             |              |
 asciiword | Word, all ASCII | it    | {english_stem} | english_stem | {}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | ate   | {english_stem} | english_stem | {ate}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | a     | {english_stem} | english_stem | {}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | fat   | {english_stem} | english_stem | {fat}
 blank     | Space symbols   |       | {}             |              |
 asciiword | Word, all ASCII | rats  | {english_stem} | english_stem | {rat}

分析器测试(ts_parse)

ts_parse函数分析文档并且返回一串记录，每一个解析后的词都有一个tokid，和的分词。如

SELECT * FROM ts_parse('default', '123 - a number');
 tokid | token
-------+--------
    22 | 123
    12 |
    12 | -
     1 | a
    12 |
     1 | number

gist 和 gin的索引类型(GiST and GIN Index Types)

这两种索引都能用在提高全文检索的速度，注意全文检索不一定非要使用索引，但是万一当一个字段被固定规律搜索时，使用索引将会有很好的效果。

CREATE INDEX name ON table USING gist(column);
创建索引 gist 索引字段的类型可以是 tsvector 或者 tsquery.
 
CREATE INDEX name ON table USING gin(column);
创建索引 gin 索引字段的类型必须是 tsvector;

1,基本操作函数

AddGeometryColumn(<schema_name>, <table_name>, <column_name>, <srid>, <type>, <dimension>)
给一个已存在属性数据表增加一个几何字段(geomtry column)。schema_name 指表的模式的名字，srid 必须是一个整数指对应于 SPATIAL_REF_SYS 表，type必须是一个大写的字符串，用来描述几何类型，例如：'POLYGON' 或者 'MULTILINESTRING'。

DropGeometryColumn(<schema_name>, <table_name>, <column_name>)
从一个空间数据表中删除一个几何字段。

ST_SetSRID(geometry, integer)
给一个几何对象(geometry)设置一个整型的SRID，对于在一个范围内的查询非常有用。 
 
2. Geometry Relationship Functions
   几何空间数据关系函数

ST_Distance(geometry, geometry)
返回两个几何对象的距离（笛卡儿距离），不使用索引。 
 
ST_DWithid(geometry, geometry, float)
如果一个几何对象(geometry)在另一个几何对象描述的距离(float)内，返回TRUE。如果有索引，会用到索引。

ST_Equals(geometry, geometry)
如果两个空间对象相等，则返回TRUE。用这个函数比用“=”更好，例如：
equals('LINESTRING(0 0, 10 10)','LINESTRING(0 0, 5 5, 10 10)') 返回 TRUE。

ST_Disjoint(geometry, geometry)
如果两个对象不相连，则返回TRUE。不要使用GeometryCollection作为参数。

ST_Intersects(geometry, geometry)
判断两个几何空间数据是否相交,如果相交返回true,不要使用GeometryCollection作为参数。
Intersects(g1, g2 ) --> Not (Disjoint(g1, g2 ))
不使用索引可以用_ST_Intersects.

ST_Touches(geometry, geometry)
如果两个几何空间对象存在接触，则返回TRUE。不要使用GeometryCollection作为参数。
a.Touches(b) -> (I(a) intersection I(b) = {empty set} ) and (a intersection b) not empty
不使用索引可以用_ST_Touches.

ST_Crosses(geometry, geometry)
如果两个几何空间对象存在交叉，则返回TRUE。不要使用GeometryCollection作为参数。
不使用索引可以用_ST_Crosses.

ST_Within(geometry A, geometry B)
如果几何空间对象A存在空间对象B中,则返回TRUE,不要使用GeometryCollection作为参数。
不使用索引可以用_ST_Within

ST_Overlaps(geometry, geometry)
如果两个几何空间数据存在交迭,则返回 TRUE,不要使用GeometryCollection作为参数。
不使用索引可以用_ST_Overlaps.

ST_Contains(geometry A, geometry B)
如果几何空间对象A包含空间对象B,则返回 TRUE,不要使用GeometryCollection作为参数。
这个函数类似于ST_Within(geometry B, geometry A)
不使用索引可以用_ST_Contains.

ST_Covers(geometry A, geometry B)
如果几何空间对象B中的所有点都在空间对象A中,则返回 TRUE。
不要使用GeometryCollection作为参数。
不使用索引可以用_ST_Covers.

ST_CoveredBy(geometry A, geometry B)
如果几何空间对象A中的所有点都在空间对象B中,则返回 TRUE。

3,Geometry Processing Functions
几何空间数据处理函数

ST_Centroid(geometry)
返回质心点,就是根据几何空间数据,活动该几何空间数据的中心点,返回一个空间点数据.

ST_Area(geometry)
如果几何空间数据为多边形,或者多多边形,则返回空间数据的外围(返回类型double precision) ;

ST_Length(geometry)
这个曲线在其相关的空间参考长度(返回类型double precision) ;

ST_PointOnSurface(geometry)
一定在几何空间线数据上的点，返回一个数据点

ST_Buffer(geometry, double, [integer])
buffer操作一个很有用函数，
这个函数的第一个参数是要操作的空间几何数据，第二个参数长度（距离），第三个参数为一个整型，
这个函数返回一个空间数据类型，以当前第一个参数空间几何数据为参考点，返回小于等于距离的空间

几何数据点，最后由这些点组成一个多边形空间数据，最后一个参数表示
在组成一个1/4圆的有几个点分隔。也就是说如果最好一个参数为8那么这个最后组成的多边形就是32边

的多边形，如果不指定这个参数，系统默认的是8
注意：第二个参数，距离它的单位为空间数据单位（度），在运算时需要进行单位换算，最后转换成度

，单位的换算关系如下：
1英里= 63360 米
1米=1/1852 海里
1海里= 1/60度
如果要进行具体的运算，需要进行一下单位换算，比如要求一个500米的范围，那么应该是

500*1/1852*1/60（度）

ST_Envelope(geometry)
这个函数可以返回mbr(空间最小外包矩形)，传入参数可以是point line polygon。

ST_extent(geometry set)
这个函数可以对一个空间数据集进行操作，返回一个最小包含矩形（mbr）.
如：SELECT EXTENT(GEOM) FROM GEOMTABLE GROUP BY CATEGORY

ST_Difference(geometry A, geometry B)
返回一个几何空间数据A不同于空间数据B的几何空间数据类型，不要使用GeometryCollection作为参数。
也就是说，如果A为一个line,B也为一个line，那么他们返回的类型就是B把A分割的多线。
如：
select ST_AsEWKT(ST_Difference(geomfromText('LINESTRING(1 1,2 3,3 4,3 1)'),geomfromText('LINESTRING(2 0,2 2,5 2,3 1)')))
返回的MULTILINESTRING((1 1,2 3,3 4,3 2),(3 2,3 1))
如果是A和B都是一个POLYGON多边形，那么返回的就是多多边形，如果相交，那么返回的就是B把A分割，并且不再B中的多多边形。
select ST_AsEWKT(ST_Difference(geomfromText('POLYGON((1 1,2 3,3 4,3 1,1 1))'),geomfromText('POLYGON((2 0,2 2,5 2,1 3,2 0))')))

ST_Union(geometry, geometry)
返回一个合并的几何空间数据，将两个几何空间数据合并为一个几何空间数据，或者GeometryCollection，不要使用GeometryCollection作为参数。

4 ，Geometry Accessors

ST_AsText(geometry)
将几何空间数据，转换成容易理解的空间数据文本格式，
例如：
(0,0 0,1 1,1 1,0 0,0)
转换后应该是这样的结果 POLYGON(0 0,0 1,1 1,1 0,0 0)

ST_SRID(geometry)
返回当前几何空间数据的SRID值

ST_IsClosed(geometry)
判断几何空间数据是否是闭合，就是判断起始点和终点坐标是相同的，如果是相同的返回true,否则返回false.

ST_IsRing(geometry)
这个函数参数的对象是line，判断起始点和终点坐标是否相同，
如果闭合(这个曲线除了起始点和终点相同外，没有其他相交点)怎返回true,否则false,

ST_NumPoints(geometry)
返回几何空间数据lineString上的第一条线上点的个数。

GeometryType(geometry)
判断几何空间数据的类型。
例如
select GeometryType(geomfromText('MULTILINESTRING((1 1,2 3,3 4,3 1,2 1,1 1),(1 2,2 3,4 5))'))
返回的类型为 MULTILINESTRING。

1.索引唯一扫描(index unique scan)
通过唯一索引查找一个数值经常返回单个ROWID。如果该唯一索引有多个列组成(即组合索引)，则至少要有组合索引的引导列参与到该查询中，如创建索引：create index index_test on building(name,status)。
如：语句：
select id from building where name='国际科技大厦'
此语句可以使用该索引。如果该语句只返回一行，则存取方法称为索引唯一扫描。
而语句：
select name from building where status ='1'
因为where条件没有用到索引的引导列。所以索引不生效。

2.索引范围扫描(index range scan)
使用一个索引存取多行数据，同上面一样，如果索引是组合索引
如:select id from building where name like 'H%' and status='1' 语句返回多行数据，此时的存取方法称为索引范围扫描。
使用index rang scan的3种情况：
(a) 在唯一索引列上使用了range操作符(> < <> >= <= between)
(b) 在组合索引上，只使用部分列进行查询，导致查询出多行
(c) 对非唯一索引列上进行的任何查询。

3. 全索引扫描(index full scan)
SQL请求的全部列（column）必须驻留在索引树中；也就是说，SELECT和WHERE字句中的所有数据列必须存在于索引中。并且排序返回。

4.索引快速扫描(index fast full scan)
扫描索引中的所有的数据块，与 index full scan很类似，但是一个显著的区别就是它不对查询出的数据进行排序，即数据不是以排序顺序被返回。

二.什么情况下应该建立索引
1.表的主关键字(建立唯一索引)
2.表的字段唯一约束
3.直接条件查询的字段,在SQL中用于条件约束的字段
4.查询中与其它表关联的字段,字段常常建立了外键关系
5.查询中排序的字段
6.查询中统计或分组统计的字段

三.什么情况下应不建或少建索引
1.表的记录很少
2.对一些经常处理的业务表应在查询允许的情况下尽量减少索引
3.数据重复且分布平均的表字段
假如一个表有10万行记录，有一个字段A只有T和F两种值，且每个值的分布概率大约为50%，那么对这种表A字段建索引一般不会提高数据库的查询速度

四.索引应用注意事项
1. IS NULL 与 IS NOT NULL
不能用null作索引，任何包含null值的列都将不会被包含在索引中。即使索引有多列这样的情况下，只要这些列中有一列含有null，该列就会从索引中排除。也就是说如果某列存在空值，即使对该列建索引也不会提高性能。 任何在where子句中使用is null或is not null的语句优化器是不允许使用索引的。

2.带通配符（%）的like语句
如： select * from building where name like '%中心%'
name为building表的索引，则此索引就不会生效，这里由于通配符（%）在搜寻词首出现，通配符如此使用会降低查询速度。然而当通配符出现在字符串其他位置时，优化器就能利用索引
select * from building where name like '&中心%'

3. Order by语句
　　ORDER BY语句决定了如何将返回的查询结果排序,任何在Order by语句的非索引项或者有计算表达式都将降低查询速度。order by后面的排序字段尽量使用索引字段。

4.'<>'的用法
例如：
select * from building where id<>5000;
select * from building where id>5000 or id<5000
结果一样，但是第二句id索引生效。

5.可以使用外部连接优化not in子句，例如：
select name from building where fk_building in (select deptid from test where name='test' and ifdeleted=0);
　　
改为：
select name from building a,test b where a.fk_building=b.id and b.name='test' and ifdeleted=0;

6.索引列是否函数的参数。如是，索引在查询时用不上。

7.主从表关联方式
如果：building.id上有一索引
在district.id上有索引
如：
select contract_code from building a,district b where a.id=b.id
building.id上的索引就会生效
反之同理。

8.是否存在潜在的数据类型转换。如将字符型数据与数值型数据比较，ORACLE会自动将字符型用to_number()函数进行转换，从而导致上一种现象的发生。

9.索引应用的优先级；

(1).唯一性索引的等级高于非唯一性索引. 这个规则只有当WHERE子句中索引列和常量比较才有效.如果索引列和其他表的索引类相比较. 这种子句在优化器中的等级是非常低的.

(2).如果多个索引在一个查询中都可应用，那么如果条件中应用索引和常量进行比较，那么这个索引先被利用。

10.语句的执行计划中有不良索引时，可以人为地屏蔽该索引，方法：
　　
　　。数值型：在索引字段上加0，例如
　　select * from building where id+0 = 0;
　　
　　。字符型：在索引字段上加‘’，例如
　　select * from building where name||’’='test';

一，介绍常用的PL/pgSQL结构和语法：
1，结构
PL/pgSQL是一种块结构的语言，比较方便的是用pgAdmin III新建Function，填入一些参数就可以了。基本上是这样的：
CREATE OR REPLACE FUNCTION 函数名(参数1，[整型 int4, 整型数组 _int4, …])
RETURNS 返回值类型 AS
$BODY$
DECLARE
变量声明
BEGIN
函数体
END;
$BODY$
LANGUAGE ‘plpgsql’ VOLATILE;

2，变量类型 除了postgresql内置的变量类型外，常用的还有 RECORD ，表示一条记录。
赋值 ：“变量 := 表达式;”
连接字符串的是“||”，比如 sql := ‘SELECT * FROM’ || table || ‘WHERE …’;
3，判断
IF 条件 THEN
…
ELSEIF 条件 THEN
…
ELSE
…
END IF;
4，循环 循环有好几种写法：
WHILE expression LOOP
statements
END LOOP;
还有常用的一种是：（从1循环到9可以写成FOR i IN 1..9 LOOP）
FOR name IN [ REVERSE ] expression .. expression LOOP
statements
END LOOP;

二 跟mysql对比较

1，postgre 中的limit不支持LIMIT #,# 这样的语法。

而是支持 LIMIT and OFFSET clauses 语法

mysql上面的两种方式都支持。
2，存储过程中在ibatis中的使用：

(1)，mysql存储过程可以直接返回结果集，同时可以有out参数
例如：
存储过程：
CREATE  PROCEDURE `test`
(IN _login VARCHAR(32),
IN _psw VARCHAR(32),
OUT _ret INTEGER(10),
 OUT _id INTEGER(10),
OUT _name VARCHAR(32),
OUT _email VARCHAR(32),
OUT _phone VARCHAR(20),
OUT _active INTEGER(11))//同时返回多个结果集合

BEGIN
    DECLARE CONTINUE HANDLER FOR NOT FOUND set _ret =-1;
    set _ret = 0 ;

    select id,name,email,phone,active
    into _id,_name,_email,_phone,_active
    from test
    where tx_account.`loginname`=_login and tx_account.`password`=MD5(_psw) and active=1;
    ---------返回结果集-----
    if _ret = 0 then
       select a.id as id ,a.name as name,a.priority as priority
       from test b left join test1 a on b.role=a.id
       where b.account=_id;
    end if;
END;
直接返回结果集
ibatis文件
  <parameterMap id="testParameterMap" class="params">
    <parameter property="loginname" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/>
    <parameter property="password" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/>
    <parameter property="ret" jdbcType="INTEGER" javaType="java.lang.Integer" mode="OUT"/>
    <parameter property="id" jdbcType="INTEGER" javaType="java.lang.Integer" mode="OUT"/>   
    <parameter property="name" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="phone" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="email" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="active" jdbcType="INTEGER" javaType="java.lang.Integer" mode="OUT"/>
  </parameterMap>
 
  <procedure id="test" parameterMap="testMap" resultMap="AccountRoleResultMap">
    {call test(?,?,?,?,?,?,?,?)}
  </procedure> 
  
dao 的实现
定义一个传参的map params ,

  HashMap<String,Object> params = new HashMap<String,Object>();
  //把需要的参数放到map中
  params.put("id",account.getId());
  params.put("ret",null);
  params.put("loginname", null);
  params.put("name", null);
  params.put("email", null);
  params.put("phone",null);
  params.put("active", null);
  定义一个list
  List list=null;
   list= (List)(getSqlMapClientTemplate().queryForList("test",params));
  //上面这样操作就可以获得存储过程返回的结果集。 
   Object var;
   var = params.get("ret");//从map 中获得制定的输出参数的值。
在mysql中不需要的ibatis的配置文件中，声明返回的结果集。
(2) postgre的函数返回结果集
在postgre中返回结果集一定要在ibatis中定义输出参数。
  方法1：不能输出参数，使用直接返游标的方法
例如：
函数：
CREATE OR REPLACE FUNCTION test(IN _login VARCHAR(32))//只有输入参数
  RETURNS
  refcursor //制定返回类型为游标。
  AS
$BODY$
declare video_cur refcursor;
BEGIN

       open video_cur for
 select id , title from test;
       return video_cur ;//返回游标
END
$BODY$
  LANGUAGE 'plpgsql' VOLATILE;
ALTER FUNCTION test(integer) OWNER TO postgres;
ibatis文件

    <parameterMap id="testParameters" class="java.util.HashMap">
        <parameter property="result" jdbcType="OTHER" javaType="java.sql.ResultSet" mode="OUT"/>//返回结果集
        <parameter property="loginName" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/>
        <parameter property="loginPasswd" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/>
    </parameterMap>
   
    <procedure id="test" resultMap="testResultMap" parameterMap="testParameters" >
         {? = call test(?,?)}
    </procedure>
   
上面的map文件描述了3个参数,按照调用方式: ? = call test(?, ?)的顺序，
第一个参数是返回结果集的，这里的jdbcType填写OTHER，javaType填写java.sql.ResultSet，
如果是ORACLE的存储过程通过游标返回结果集的话，jdbcType应该填写为ORACLECURSOR，
不过在PostgreSQL中不能用ORACLECURSOR，得用OTHER。

dao的实现：
定义map文件 parameters ；
 List list;
        HashMap<String, String> parameters = new HashMap<String, String>();
        parameters.put("loginName", loginName);
        parameters.put("loginPasswd", loginPasswd);
        list=getSqlMapClientTemplate().queryForList("test", parameters);//这样来得到返回的结果集。
 return list;
方法2： 同时返回多个结果，

函数：
CREATE OR REPLACE FUNCTION test(IN _login VARCHAR(32),
IN _psw VARCHAR(32),
OUT _ret INTEGER,
 OUT _id INTEGER,
OUT _name VARCHAR(32),
OUT _email VARCHAR(32),
OUT _phone VARCHAR(20),
OUT _ref refcursor ---返回一个游标
)
  RETURNS record
  AS
$BODY$
declare video_cur refcursor;
BEGIN
    select id,name,email,phone
    into _id,_name,_email,_phone
    from test
    where tx_account.`loginname`=_login and tx_account.`password`=MD5(_psw) and active=1;

    open _ref  for
    select id , title from test1;
END
$BODY$
  LANGUAGE 'plpgsql' VOLATILE;
ALTER FUNCTION test(integer) OWNER TO postgres;

如果返回多个结果集，就要使用返回伪类型 record可以在输出参数中指定游标为其中一个out参数
ibatis文件

        out 参数输出游标
 <parameterMap id="ParameterMap" class="map" >  
    <parameter property="login " jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/> 
    <parameter property="password" jdbcType="VARCHAR" javaType="java.lang.String" mode="IN"/>
    <parameter property="ret" jdbcType="INTEGER" javaType="java.lang.Integer" mode="OUT"/>
    <parameter property="id" jdbcType="INTEGER" javaType="java.lang.Integer" mode="OUT"/>   
    <parameter property="name" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="phone" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="email" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
    <parameter property="ref" jdbcType="OTHER" javaType="java.sql.ResultSet" mode="OUT"/>  //返回结果集    

   </parameterMap>

 <procedure id="test" parameterMap="ParameterMap" resultMap="ResultMap">    
     {call test(?,?,?,?,?,?,?,?)} 
   </procedure>

dao的实现跟方法1 相同