27.2.2. Full-Text Parser Plugins
MySQL has a built-in parser that it uses by default for
full-text operations (parsing text to be indexed, or parsing a
query string to determine the terms to be used for a search).
For full-text processing, “parsing” means
extracting words from text or a query string based on rules that
define which character sequences make up a word and where word
boundaries lie.
When parsing for indexing purposes, the parser passes each word
to the server, which adds it to a full-text index. When parsing
a query string, the parser passes each word to the server, which
accumulates the words for use in a search.
The parsing properties of the built-in full-text parser are
described in Section 12.7, “Full-Text Search Functions”. These properties
include rules for determining how to extract words from text.
The parser is influenced by certain system variables such as
ft_min_word_len and
ft_max_word_len that cause words shorter or
longer to be excluded, and by the stopword list that identifies
common words to be ignored.
The plugin API enables you to provide a full-text parser of your
own so that you have control over the basic duties of a parser.
A parser plugin can operate in either of two roles:
-
The plugin can replace the built-in parser. In this role,
the plugin reads the input to be parsed, splits it up into
words, and passes the words to the server (either for
indexing or for word accumulation).
One reason to use a parser this way is that you need to use
different rules from those of the built-in parser for
determining how to split up input into words. For example,
the built-in parser considers the text
“case-sensitive” to consist of two words
“case” and “sensitive,” whereas an
application might need to treat the text as a single word.
-
The plugin can act in conjunction with the built-in parser
by serving as a front end for it. In this role, the plugin
extracts text from the input and passes the text to the
parser, which splits up the text into words using its normal
parsing rules. In particular, this parsing will be affected
by the ft_xxx
system variables and the stopword list.
One reason to use a parser this way is that you need to
index content such as PDF documents, XML documents, or
.doc files. The built-in parser is not
intended for those types of input but a plugin can pull out
the text from these input sources and pass it to the
built-in parser.
It is also possible for a parser plugin to operate in both
roles. That is, it could extract text from non-plaintext input
(the front end role), and also parse the text into words (thus
replacing the built-in parser).
A full-text plugin is associated with full-text indexes on a
per-index basis. That is, when you install a parser plugin
initially, that does not cause it to be used for any full-text
operations. It simply becomes available. For example, a
full-text parser plugin becomes available to be named in a
WITH PARSER clause when creating individual
FULLTEXT indexes. To create such an index at
table-creation time, do this:
CREATE TABLE t
(
doc CHAR(255),
FULLTEXT INDEX (doc) WITH PARSER my_parser
);
Or you can add the index after the table has been created:
ALTER TABLE t ADD FULLTEXT INDEX (doc) WITH PARSER my_parser;
The only SQL change for associating the parser with the index is
the WITH PARSER clause. Searches are
specified as before, with no changes needed for queries.
When you associate a parser plugin with a
FULLTEXT index, the plugin is required for
using the index. If the parser plugin is dropped, any index
associated with it becomes unusable. Any attempt to use it a
table for which a plugin is not available results in an error,
although DROP TABLE is still possible.
