Postgres Pro Enterprise : Документация: 10: 9.13. Функции и операторы текстового поиска : Компания Postgres Professional

9.13. Функции и операторы текстового поиска
Пред.	Наверх	Глава 9. Функции и операторы	Начало	След.

9.13. Функции и операторы текстового поиска

В Таблице 9.40, Таблице 9.41 и Таблице 9.42 собраны все существующие функции и операторы, предназначенные для полнотекстового поиска. Во всех деталях возможности полнотекстового поиска в Postgres Pro описаны в Главе 12.

Таблица 9.40. Операторы текстового поиска

Оператор	Тип результата	Описание	Пример	Результат
`@@`	`boolean`	`tsvector` соответствует `tsquery` ?	`to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')`	`t`
`@@@`	`boolean`	устаревший синоним для `@@`	`to_tsvector('fat cats ate rats') @@@ to_tsquery('cat & rat')`	`t`
`\|\|`	`tsvector`	объединяет два значения `tsvector`	`'a:1 b:2'::tsvector \|\| 'c:1 d:2 b:3'::tsvector`	`'a':1 'b':2,5 'c':3 'd':4`
`&&`	`tsquery`	логическое И (AND) двух запросов `tsquery`	`'fat \| rat'::tsquery && 'cat'::tsquery`	`( 'fat' \| 'rat' ) & 'cat'`
`\|\|`	`tsquery`	логическое ИЛИ (OR) двух запросов `tsquery`	`'fat \| rat'::tsquery \|\| 'cat'::tsquery`	`( 'fat' \| 'rat' ) \| 'cat'`
`!!`	`tsquery`	отрицание запроса `tsquery`	`!! 'cat'::tsquery`	`!'cat'`
`<->`	`tsquery`	`tsquery` предшествует `tsquery`	`to_tsquery('fat') <-> to_tsquery('rat')`	`'fat' <-> 'rat'`
`@>`	`boolean`	запрос `tsquery` включает другой?	`'cat'::tsquery @> 'cat & rat'::tsquery`	`f`
`<@`	`boolean`	запрос `tsquery` включён в другой?	`'cat'::tsquery <@ 'cat & rat'::tsquery`	`t`

Примечание

Операторы включения tsquery рассматривают только лексемы двух запросов, игнорируя операторы их сочетания.

В дополнение к операторам, перечисленным в этой таблице, для типов tsvector и tsquery определены обычные операторы сравнения для B-дерева (=, < и т. д.). Они не очень полезны для поиска, но позволяют, в частности, создавать индексы для столбцов этих типов.

Таблица 9.41. Функции текстового поиска

Функция	Тип результата	Описание	Пример	Результат
`array_to_tsvector(text[])`	`tsvector`	преобразует массив лексем в `tsvector`	`array_to_tsvector('{fat,cat,rat}'::text[])`	`'cat' 'fat' 'rat'`
`get_current_ts_config()`	`regconfig`	получает конфигурацию текстового поиска по умолчанию	`get_current_ts_config()`	`english`
`length(tsvector)`	`integer`	число лексем в значении `tsvector`	`length('fat:2,4 cat:3 rat:5A'::tsvector)`	`3`
`numnode(tsquery)`	`integer`	число лексем и операторов в запросе `tsquery`	`numnode('(fat & rat) \| cat'::tsquery)`	`5`
`plainto_tsquery([конфигурация regconfig ,] запрос text)`	`tsquery`	выдаёт значение `tsquery`, игнорируя пунктуацию	`plainto_tsquery('english', 'The Fat Rats')`	`'fat' & 'rat'`
`phraseto_tsquery([конфигурация regconfig ,] запрос text)`	`tsquery`	выдаёт значение `tsquery` для поиска фразы, игнорируя пунктуацию	`phraseto_tsquery('english', 'The Fat Rats')`	`'fat' <-> 'rat'`
`querytree(запрос tsquery)`	`text`	получает индексируемую часть запроса `tsquery`	`querytree('foo & ! bar'::tsquery)`	`'foo'`
`setweight(вектор tsvector, вес "char")`	`tsvector`	назначает `вес` каждому элементу `вектора`	`setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')`	`'cat':3A 'fat':2A,4A 'rat':5A`
`setweight(вектор tsvector, вес "char", лексемы text[])`	`tsvector`	назначает `вес` элементам `вектора`, перечисленным в массиве `лексемы`	`setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A', '{cat,rat}')`	`'cat':3A 'fat':2,4 'rat':5A`
`strip(tsvector)`	`tsvector`	убирает позиции и веса из значения `tsvector`	`strip('fat:2,4 cat:3 rat:5A'::tsvector)`	`'cat' 'fat' 'rat'`
`to_tsquery([конфигурация regconfig ,] запрос text)`	`tsquery`	нормализует слова и переводит их в `tsquery`	`to_tsquery('english', 'The & Fat & Rats')`	`'fat' & 'rat'`
`to_tsvector([конфигурация regconfig ,] документ text)`	`tsvector`	сокращает текст документа до значения `tsvector`	`to_tsvector('english', 'The Fat Rats')`	`'fat':2 'rat':3`
`to_tsvector([конфигурация regconfig ,] документ json(b))`	`tsvector`	сокращает каждое строковое значение в документе до значения `tsvector`, а затем складывает эти значения по порядку в документе и выдаёт один `tsvector`	`to_tsvector('english', '{"a": "The Fat Rats"}'::json)`	`'fat':2 'rat':3`
`ts_delete(вектор tsvector, лексема text)`	`tsvector`	удаляет заданную `лексему` из `вектора`	`ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat')`	`'cat':3 'rat':5A`
`ts_delete(вектор tsvector, лексемы text[])`	`tsvector`	удаляет все вхождения лексем, перечисленных в массиве `лексемы`, из `вектора`	`ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat'])`	`'cat':3`
`ts_filter(вектор tsvector, веса "char"[])`	`tsvector`	выбирает из `вектора` только элементы с заданным `весом`	`ts_filter('fat:2,4 cat:3b rat:5A'::tsvector, '{a,b}')`	`'cat':3B 'rat':5A`
`ts_headline([конфигурация regconfig,] документ text, запрос tsquery [, параметры text])`	`text`	выводит фрагмент, соответствующий запросу	`ts_headline('x y z', 'z'::tsquery)`	`x y <b>z</b>`
`ts_headline([конфигурация regconfig,] документ json(b), запрос tsquery [, параметры text])`	`text`	выводит фрагмент, соответствующий запросу	`ts_headline('{"a":"x y z"}'::json, 'z'::tsquery)`	`{"a":"x y <b>z</b>"}`
`ts_rank([веса float4[],] вектор tsvector, запрос tsquery [, нормализация integer])`	`float4`	вычисляет ранг документа по отношению к запросу	`ts_rank(textsearch, query)`	`0.818`
`ts_rank_cd([веса float4[],] вектор tsvector, запрос tsquery [, нормализация integer])`	`float4`	вычисляет ранг документа по отношению к запросу, используя плотность покрытия (CDR)	`ts_rank_cd('{0.1, 0.2, 0.4, 1.0}', textsearch, query)`	`2.01317`
`ts_rewrite(запрос tsquery, цель tsquery, замена tsquery)`	`tsquery`	подставляет в запросе вместо `цели` `замену`	`ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo\|bar'::tsquery)`	`'b' & ( 'foo' \| 'bar' )`
`ts_rewrite(запрос tsquery, выборка text)`	`tsquery`	заменяет элементы запроса, выбирая цели и подстановки командой `SELECT`	`SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases')`	`'b' & ( 'foo' \| 'bar' )`
`tsquery_phrase(запрос1 tsquery, запрос2 tsquery)`	`tsquery`	создаёт запрос, который ищет `запрос1`, за которым идёт `запрос2` (как делает оператор `<->`)	`tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))`	`'fat' <-> 'cat'`
`tsquery_phrase(запрос1 tsquery, запрос2 tsquery, расстояние integer)`	`tsquery`	создаёт запрос, который ищет `запрос1`, за которым идёт `запрос2` на заданном `расстоянии`	`tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10)`	`'fat' <10> 'cat'`
`tsvector_to_array(tsvector)`	`text[]`	преобразует `tsvector` в массив лексем	`tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector)`	`{cat,fat,rat}`
`tsvector_update_trigger()`	`trigger`	триггерная функция для автоматического изменения столбца типа `tsvector`	`CREATE TRIGGER ... tsvector_update_trigger(tsvcol, 'pg_catalog.swedish', title, body)`
`tsvector_update_trigger_column()`	`trigger`	триггерная функция для автоматического изменения столбца типа `tsvector`	`CREATE TRIGGER ... tsvector_update_trigger_column(tsvcol, configcol, title, body)`
`unnest(tsvector, OUT лексема text, OUT позиции smallint[], OUT веса text)`	`setof record`	разворачивает `tsvector` в набор строк	`unnest('fat:2,4 cat:3 rat:5A'::tsvector)`	`(cat,{3},{D}) ...`

Примечание

Все функции текстового поиска, принимающие необязательный аргумент regconfig, будут использовать конфигурацию, указанную в параметре default_text_search_config, когда этот аргумент опущен.

Функции в Таблице 9.42 перечислены отдельно, так как они не очень полезны в традиционных операциях поиска. Они предназначены в основном для разработки и отладки новых конфигураций текстового поиска.

Таблица 9.42. Функции отладки текстового поиска

Функция	Тип результата	Описание	Пример	Результат
`ts_debug([конфигурация regconfig,] документ text, OUT псевдоним text, OUT описание text, OUT фрагмент text, OUT словари regdictionary[], OUT словарь regdictionary, OUT лексемы text[])`	`setof record`	проверяет конфигурацию	`ts_debug('english', 'The Brightest supernovaes')`	`(asciiword,"Word, all ASCII",The,{english_stem},english_stem,{}) ...`
`ts_lexize(словарь regdictionary, фрагмент text)`	`text[]`	проверяет словарь	`ts_lexize('english_stem', 'stars')`	`{star}`
`ts_parse(имя_анализатора text, документ text, OUT код_фрагмента integer, OUT фрагмент text)`	`setof record`	проверяет анализатор	`ts_parse('default', 'foo - bar')`	`(1,foo) ...`
`ts_parse(oid_анализатора oid, документ text, OUT код_фрагмента integer, OUT фрагмент text)`	`setof record`	проверяет анализатор	`ts_parse(3722, 'foo - bar')`	`(1,foo) ...`
`ts_token_type(имя_анализатора text, OUT код_фрагмента integer, OUT псевдоним text, OUT описание text)`	`setof record`	получает типы фрагментов, определённые анализатором	`ts_token_type('default')`	`(1,asciiword,"Word, all ASCII") ...`
`ts_token_type(oid_анализатора oid, OUT код_фрагмента integer, OUT псевдоним text, OUT описание text)`	`setof record`	получает типы фрагментов, определённые анализатором	`ts_token_type(3722)`	`(1,asciiword,"Word, all ASCII") ...`
`ts_stat(sql_запрос text, [веса text,] OUT слово text, OUT число_док integer, OUT число_вхожд integer)`	`setof record`	получает статистику столбца `tsvector`	`ts_stat('SELECT vector from apod')`	`(foo,10,15) ...`

Пред.	Наверх	След.
9.12. Функции и операторы для работы с сетевыми адресами	Начало	9.14. XML-функции

9.13. Text Search Functions and Operators
Prev	Up	Chapter 9. Functions and Operators	Home	Next

9.13. Text Search Functions and Operators

Table 9.40, Table 9.41 and Table 9.42 summarize the functions and operators that are provided for full text searching. See Chapter 12 for a detailed explanation of Postgres Pro's text search facility.

Table 9.40. Text Search Operators

Operator	Return Type	Description	Example	Result
`@@`	`boolean`	`tsvector` matches `tsquery` ?	`to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')`	`t`
`@@@`	`boolean`	deprecated synonym for `@@`	`to_tsvector('fat cats ate rats') @@@ to_tsquery('cat & rat')`	`t`
`\|\|`	`tsvector`	concatenate `tsvector`s	`'a:1 b:2'::tsvector \|\| 'c:1 d:2 b:3'::tsvector`	`'a':1 'b':2,5 'c':3 'd':4`
`&&`	`tsquery`	AND `tsquery`s together	`'fat \| rat'::tsquery && 'cat'::tsquery`	`( 'fat' \| 'rat' ) & 'cat'`
`\|\|`	`tsquery`	OR `tsquery`s together	`'fat \| rat'::tsquery \|\| 'cat'::tsquery`	`( 'fat' \| 'rat' ) \| 'cat'`
`!!`	`tsquery`	negate a `tsquery`	`!! 'cat'::tsquery`	`!'cat'`
`<->`	`tsquery`	`tsquery` followed by `tsquery`	`to_tsquery('fat') <-> to_tsquery('rat')`	`'fat' <-> 'rat'`
`@>`	`boolean`	`tsquery` contains another ?	`'cat'::tsquery @> 'cat & rat'::tsquery`	`f`
`<@`	`boolean`	`tsquery` is contained in ?	`'cat'::tsquery <@ 'cat & rat'::tsquery`	`t`

Note

The tsquery containment operators consider only the lexemes listed in the two queries, ignoring the combining operators.

In addition to the operators shown in the table, the ordinary B-tree comparison operators (=, <, etc) are defined for types tsvector and tsquery. These are not very useful for text searching but allow, for example, unique indexes to be built on columns of these types.

Table 9.41. Text Search Functions

Function	Return Type	Description	Example	Result
`array_to_tsvector(text[])`	`tsvector`	convert array of lexemes to `tsvector`	`array_to_tsvector('{fat,cat,rat}'::text[])`	`'cat' 'fat' 'rat'`
`get_current_ts_config()`	`regconfig`	get default text search configuration	`get_current_ts_config()`	`english`
`length(tsvector)`	`integer`	number of lexemes in `tsvector`	`length('fat:2,4 cat:3 rat:5A'::tsvector)`	`3`
`numnode(tsquery)`	`integer`	number of lexemes plus operators in `tsquery`	`numnode('(fat & rat) \| cat'::tsquery)`	`5`
`plainto_tsquery([ config regconfig , ] query text)`	`tsquery`	produce `tsquery` ignoring punctuation	`plainto_tsquery('english', 'The Fat Rats')`	`'fat' & 'rat'`
`phraseto_tsquery([ config regconfig , ] query text)`	`tsquery`	produce `tsquery` that searches for a phrase, ignoring punctuation	`phraseto_tsquery('english', 'The Fat Rats')`	`'fat' <-> 'rat'`
`querytree(query tsquery)`	`text`	get indexable part of a `tsquery`	`querytree('foo & ! bar'::tsquery)`	`'foo'`
`setweight(vector tsvector, weight "char")`	`tsvector`	assign `weight` to each element of `vector`	`setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')`	`'cat':3A 'fat':2A,4A 'rat':5A`
`setweight(vector tsvector, weight "char", lexemes text[])`	`tsvector`	assign `weight` to elements of `vector` that are listed in `lexemes`	`setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A', '{cat,rat}')`	`'cat':3A 'fat':2,4 'rat':5A`
`strip(tsvector)`	`tsvector`	remove positions and weights from `tsvector`	`strip('fat:2,4 cat:3 rat:5A'::tsvector)`	`'cat' 'fat' 'rat'`
`to_tsquery([ config regconfig , ] query text)`	`tsquery`	normalize words and convert to `tsquery`	`to_tsquery('english', 'The & Fat & Rats')`	`'fat' & 'rat'`
`to_tsvector([ config regconfig , ] document text)`	`tsvector`	reduce document text to `tsvector`	`to_tsvector('english', 'The Fat Rats')`	`'fat':2 'rat':3`
`to_tsvector([ config regconfig , ] document json(b))`	`tsvector`	reduce each string value in the document to a `tsvector`, and then concatenate those in document order to produce a single `tsvector`	`to_tsvector('english', '{"a": "The Fat Rats"}'::json)`	`'fat':2 'rat':3`
`ts_delete(vector tsvector, lexeme text)`	`tsvector`	remove given `lexeme` from `vector`	`ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat')`	`'cat':3 'rat':5A`
`ts_delete(vector tsvector, lexemes text[])`	`tsvector`	remove any occurrence of lexemes in `lexemes` from `vector`	`ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat'])`	`'cat':3`
`ts_filter(vector tsvector, weights "char"[])`	`tsvector`	select only elements with given `weights` from `vector`	`ts_filter('fat:2,4 cat:3b rat:5A'::tsvector, '{a,b}')`	`'cat':3B 'rat':5A`
`ts_headline([ config regconfig, ] document text, query tsquery [, options text ])`	`text`	display a query match	`ts_headline('x y z', 'z'::tsquery)`	`x y <b>z</b>`
`ts_headline([ config regconfig, ] document json(b), query tsquery [, options text ])`	`text`	display a query match	`ts_headline('{"a":"x y z"}'::json, 'z'::tsquery)`	`{"a":"x y <b>z</b>"}`
`ts_rank([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])`	`float4`	rank document for query	`ts_rank(textsearch, query)`	`0.818`
`ts_rank_cd([ weights float4[], ] vector tsvector, query tsquery [, normalization integer ])`	`float4`	rank document for query using cover density	`ts_rank_cd('{0.1, 0.2, 0.4, 1.0}', textsearch, query)`	`2.01317`
`ts_rewrite(query tsquery, target tsquery, substitute tsquery)`	`tsquery`	replace `target` with `substitute` within query	`ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo\|bar'::tsquery)`	`'b' & ( 'foo' \| 'bar' )`
`ts_rewrite(query tsquery, select text)`	`tsquery`	replace using targets and substitutes from a `SELECT` command	`SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases')`	`'b' & ( 'foo' \| 'bar' )`
`tsquery_phrase(query1 tsquery, query2 tsquery)`	`tsquery`	make query that searches for `query1` followed by `query2` (same as `<->` operator)	`tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))`	`'fat' <-> 'cat'`
`tsquery_phrase(query1 tsquery, query2 tsquery, distance integer)`	`tsquery`	make query that searches for `query1` followed by `query2` at distance `distance`	`tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10)`	`'fat' <10> 'cat'`
`tsvector_to_array(tsvector)`	`text[]`	convert `tsvector` to array of lexemes	`tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector)`	`{cat,fat,rat}`
`tsvector_update_trigger()`	`trigger`	trigger function for automatic `tsvector` column update	`CREATE TRIGGER ... tsvector_update_trigger(tsvcol, 'pg_catalog.swedish', title, body)`
`tsvector_update_trigger_column()`	`trigger`	trigger function for automatic `tsvector` column update	`CREATE TRIGGER ... tsvector_update_trigger_column(tsvcol, configcol, title, body)`
`unnest(tsvector, OUT lexeme text, OUT positions smallint[], OUT weights text)`	`setof record`	expand a `tsvector` to a set of rows	`unnest('fat:2,4 cat:3 rat:5A'::tsvector)`	`(cat,{3},{D}) ...`

Note

All the text search functions that accept an optional regconfig argument will use the configuration specified by default_text_search_config when that argument is omitted.

The functions in Table 9.42 are listed separately because they are not usually used in everyday text searching operations. They are helpful for development and debugging of new text search configurations.

Table 9.42. Text Search Debugging Functions

Function	Return Type	Description	Example	Result
`ts_debug([ config regconfig, ] document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[])`	`setof record`	test a configuration	`ts_debug('english', 'The Brightest supernovaes')`	`(asciiword,"Word, all ASCII",The,{english_stem},english_stem,{}) ...`
`ts_lexize(dict regdictionary, token text)`	`text[]`	test a dictionary	`ts_lexize('english_stem', 'stars')`	`{star}`
`ts_parse(parser_name text, document text, OUT tokid integer, OUT token text)`	`setof record`	test a parser	`ts_parse('default', 'foo - bar')`	`(1,foo) ...`
`ts_parse(parser_oid oid, document text, OUT tokid integer, OUT token text)`	`setof record`	test a parser	`ts_parse(3722, 'foo - bar')`	`(1,foo) ...`
`ts_token_type(parser_name text, OUT tokid integer, OUT alias text, OUT description text)`	`setof record`	get token types defined by parser	`ts_token_type('default')`	`(1,asciiword,"Word, all ASCII") ...`
`ts_token_type(parser_oid oid, OUT tokid integer, OUT alias text, OUT description text)`	`setof record`	get token types defined by parser	`ts_token_type(3722)`	`(1,asciiword,"Word, all ASCII") ...`
`ts_stat(sqlquery text, [ weights text, ] OUT word text, OUT ndoc integer, OUT nentry integer)`	`setof record`	get statistics of a `tsvector` column	`ts_stat('SELECT vector from apod')`	`(foo,10,15) ...`

Prev	Up	Next
9.12. Network Address Functions and Operators	Home	9.14. XML Functions