rroonga 2.0.4-x86-mingw32 → 2.0.7-x86-mingw32

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/grn_expr/script_syntax.txt

@@ -0,0 +1,805 @@
+.. -*- rst -*-
+
+.. highlightlang:: none
+
+.. groonga-command
+.. database: reference_grn_expr_script_syntax
+
+Script syntax
+=============
+
+Script syntax is a syntax to specify complex search condition. It is
+similar to ECMAScript. For example, ``_key == "book"`` means that
+groonga searches records that ``_key`` value is ``"book"``. All values
+are string in :doc:`query_syntax` but its own type in script
+syntax. For example, ``"book"`` is string, ``1`` is integer,
+``TokenBigram`` is the object whose name is ``TokenBigram`` and so on.
+
+Script syntax doesn't support full ECMAScript syntax. For example,
+script syntax doesn't support statement such as ``if`` control
+statement, ``for`` iteration statement and variable definition
+statement. Function definion is not supported too. But script syntax
+addes the original additional operators.  They are described after
+ECMAScript syntax is described.
+
+Sample data
+-----------
+
+Here are a schema definition and sample data to show usage.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/query_syntax/setup.log
+.. table_create Entries TABLE_PAT_KEY ShortText
+.. column_create Entries content COLUMN_SCALAR Text
+.. column_create Entries n_likes COLUMN_SCALAR UInt32
+.. table_create Terms TABLE_PAT_KEY|KEY_NORMALIZE ShortText --default_tokenizer TokenBigram
+.. column_create Terms entries_key_index COLUMN_INDEX|WITH_POSITION Entries _key
+.. column_create Terms entries_content_index COLUMN_INDEX|WITH_POSITION Entries content
+.. load --table Entries
+.. [
+.. {"_key":    "The first post!",
+..  "content": "Welcome! This is my first post!",
+..  "n_likes": 5},
+.. {"_key":    "Groonga",
+..  "content": "I started to use groonga. It's very fast!",
+..  "n_likes": 10},
+.. {"_key":    "Mroonga",
+..  "content": "I also started to use mroonga. It's also very fast! Really fast!",
+..  "n_likes": 15},
+.. {"_key":    "Good-bye Senna",
+..  "content": "I migrated all Senna system!",
+..  "n_likes": 3},
+.. {"_key":    "Good-bye Tritonn",
+..  "content": "I also migrated all Tritonn system!",
+..  "n_likes": 3}
+.. ]
+
+There is a table, ``Entries``, for blog entries. An entry has title,
+content and the number of likes for the entry. Title is key of
+``Entries``. Content is value of ``Entries.content`` column. The
+number of likes is value of ``Entries.n_likes`` column.
+
+``Entries._key`` column and ``Entries.content`` column are indexed
+using ``TokenBigram`` tokenizer. So both ``Entries._key`` and
+``Entries.content`` are fulltext search ready.
+
+OK. The schema and data for examples are ready.
+
+Literals
+--------
+
+Integer
+^^^^^^^
+
+Integer literal is sequence of ``0`` to ``9`` such as
+``1234567890``. ``+`` or ``-`` can be prepended as sign such as
+``+29`` and ``-29``. Integer literal must be decimal. Octal notation,
+hex and so on can't be used.
+
+The maximum value of integer literal is ``9223372036854775807`` (``= 2
+** 63 - 1``). The minimum value of integer literal is
+``-9223372036854775808`` (``= -(2 ** 63)``).
+
+Float
+^^^^^
+
+Float literal is sequence of ``0`` to ``9``, ``.`` and ``0`` to ``9``
+such as ``3.14``. ``+`` or ``-`` can be prepended as sign such as
+``+3.14`` and ``-3.14``. ``${RADIX}e${EXPORNENTIAL}`` and
+``${RADIX}E${EXPORNENTIAL}`` formats are also supported. For example,
+``314e-2`` is the same as ``3.14``.
+
+String
+^^^^^^
+
+String literal is ``"..."``. You need to escape ``"`` in literal by
+prepending ``\\'' such as ``\"``. For example, ``"Say \"Hello!\"."`` is
+a literal for ``Say "Hello!".`` string.
+
+String encoding must be the same as encoding of database. The default
+encoding is UTF-8. It can be changed by ``--with-default-encoding``
+configure option, ``--encodiong`` :doc:`/reference/executables/groonga` option
+and so on.
+
+Boolean
+^^^^^^^
+
+Boolean literal is ``true`` and ``false``. ``true`` means true and
+``false`` means false.
+
+Null
+^^^^
+
+Null literal is ``null``. Groonga doesn't support null value but null
+literal is supported.
+
+Time
+^^^^
+
+.. note::
+
+   This is the groonga original notation.
+
+Time literal doesn't exit. There are string time notation, integer
+time notation and float time notation.
+
+String time notation is ``"YYYY/MM/DD hh:mm:ss.uuuuuu"`` or
+``"YYYY-MM-DD hh:mm:ss.uuuuuu"``. ``YYYY`` is year, ``MM`` is month,
+``DD`` is day, ``hh`` is hour, ``mm`` is minute, ``ss`` is second and
+``uuuuuu`` is micro second. It is local time. For example,
+``"2012/07/23 02:41:10.436218"`` is ``2012-07-23T02:41:10.436218`` in
+ISO 8601 format.
+
+Integer time notation is the number of seconds that have elapsed since
+midnight UTC, January 1, 1970. It is also known as POSIX time. For
+example, ``1343011270`` is ``2012-07-23T02:41:10Z`` in ISO 8601 format.
+
+Float time notation is the number of seconds and micro seconds that
+have elapsed since midnight UTC, January 1, 1970. For example,
+``1343011270.436218`` is ``2012-07-23T02:41:10.436218Z`` in ISO 8601
+format.
+
+Geo point
+^^^^^^^^^
+
+.. note::
+
+   This is the groonga original notation.
+
+Geo point literal doesn't exist. There is string geo point notation.
+
+String geo point notation has the following patterns:
+
+  * ``"LATITUDE_IN_MSECxLONGITUDE_IN_MSEC"``
+  * ``"LATITUDE_IN_MSEC,LONGITUDE_IN_MSEC"``
+  * ``"LATITUDE_IN_DEGREExLONGITUDE_IN_DEGREE"``
+  * ``"LATITUDE_IN_DEGREE,LONGITUDE_IN_DEGREE"``
+
+``x`` and ``,`` can be used for separator. Latitude and longitude can
+be represented in milliseconds or degree.
+
+Array
+^^^^^
+
+Array literal is ``[element1, element2, ...]``.
+
+Object literal
+^^^^^^^^^^^^^^
+
+Object literal is ``{name1: value1, name2: value2, ...}``. Groonga
+doesn't support object literal yet.
+
+Control syntaxes
+----------------
+
+Script syntax doesn't support statement. So you cannot use control
+statement such as ``if``. You can only use ``A ? B : C`` expression as
+control syntax.
+
+``A ? B : C`` returns ``B`` if ``A`` is true, ``C`` otherwise.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_control_syntax_ternary_operator.log
+.. select Entries --filter 'n_likes == (_id == 1 ? 5 : 3)'
+
+The expression matches records that ``_id`` column value is equal to ``1``
+and ``n_likes`` column value is equal to ``5`` or ``_id`` column value is
+not equal to 1 and ``n_likes`` column value is equal to ``3``.
+
+Grouping
+--------
+
+Its syntax is ``(...)``. ``...`` is comma separated expression list.
+
+``(...)`` groups one ore more expressions and they can be processed as
+an expression. ``a && b || c`` means that ``a`` and ``b`` are matched
+or ``c`` is matched. ``a && (b || c)`` means that ``a`` and one of
+``b`` and ``c`` are matched.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_grouping.log
+.. select Entries --filter 'n_likes < 5 && content @ "senna" || content @ "fast"'
+.. select Entries --filter 'n_likes < 5 && (content @ "senna" || content @ "fast")'
+
+The first expression doesn't use grouping. It matches records that
+``n_likes < 5`` and ``content @ "senna"`` are matched or
+``content @ "fast"`` is matched.
+
+The second expression uses grouping. It matches records that ``n_likes
+< 5`` and one of ``content @ "senna"`` or ``content @ "fast"`` are
+matched.
+
+Function call
+-------------
+
+Its syntax is ``name(arugment1, argument2, ...)``.
+
+``name(argument1, argument2, ...)`` calls a function that is named
+``name`` with arguments ``argument1``, ``argument2`` and ``...``.
+
+See :doc:`/reference/functions/` for available functin list.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_function.log
+.. select Entries --filter 'edit_distance(_key, "Groonga") <= 1'
+
+The expression uses :doc:`/reference/functions/edit_distance`. It
+matches records that ``_key`` column value is similar to
+``"Groonga"``. Similality of ``"Groonga"`` is computed as edit
+distance. If edit distance is less than or equal to 1, the value is
+treated as similar. In this case, ``"Groonga"`` and ``"Mroonga"`` are
+treated as similar.
+
+Basic operators
+---------------
+
+Groonga supports operators defined in ECMAScript.
+
+Arithmetic operators
+^^^^^^^^^^^^^^^^^^^^
+
+Here are arithmetic operators.
+
+Addition operator
+"""""""""""""""""
+
+Its syntax is ``number1 + number2``.
+
+The operator adds ``number1`` and ``number2`` and returns the result.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_addition_operator.log
+.. select Entries --filter 'n_likes == 10 + 5'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``15`` (= ``10 + 5``).
+
+Subtraction operator
+""""""""""""""""""""
+
+Its syntax is ``number1 - number2``.
+
+The operator subtracts ``number2`` from ``number1`` and returns the result.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_subtraction_operator.log
+.. select Entries --filter 'n_likes == 20 - 5'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``15`` (= ``20 - 5``).
+
+Multiplication operator
+"""""""""""""""""""""""
+
+Its syntax is ``number1 * number2``.
+
+The operator multiplies ``number1`` and ``number2`` and returns the result.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_multiplication_operator.log
+.. select Entries --filter 'n_likes == 3 * 5'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``15`` (= ``3 * 5``).
+
+Division operator
+"""""""""""""""""
+
+Its syntax is ``number1 / number2`` and ``number1 % number2``.
+
+The operator divides ``number2`` by ``number1``. ``/`` returns the
+quotient of result. ``%`` returns the remainder of result.
+
+Here is simple examples.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_division_operator_quotient.log
+.. select Entries --filter 'n_likes == 26 / 7'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``3`` (= ``26 / 7``).
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_division_operator_remainder.log
+.. select Entries --filter 'n_likes == 26 % 7'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` (= ``26 % 7``).
+
+Logical operators
+^^^^^^^^^^^^^^^^^
+
+Here are logical operators.
+
+Logical NOT operator
+""""""""""""""""""""
+
+Its syntax is ``!condition``.
+
+The operator inverts boolean value of ``condition``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_logical_not_operator.log
+.. select Entries --filter '!(n_likes == 5)'
+
+The expression matches records that ``n_likes`` column value is not
+equal to ``5``.
+
+Logical AND operator
+""""""""""""""""""""
+
+Its syntax is ``condition1 && condition2``.
+
+The operator returns true if both of ``condition1`` and
+``condition2`` are true, false otherwise.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_logical_and_operator.log
+.. select Entries --filter 'content @ "fast" && n_likes >= 10'
+
+The expression matches records that ``content`` column value has the
+word ``fast`` and ``n_likes`` column value is greater or equal to
+``10``.
+
+Logical OR operator
+"""""""""""""""""""
+
+Its syntax is ``condition1 || condition2``.
+
+The operator returns true if either ``condition1`` or ``condition2`` is
+true, false otherwise.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_logical_or_operator.log
+.. select Entries --filter 'n_likes == 5 || n_likes == 10'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` or ``10``.
+
+Logical AND NOT operator
+""""""""""""""""""""""""
+
+Its syntax is ``condition1 &! condition2``.
+
+The operator returns true if ``condition1`` is true but ``condition2``
+is false, false otherwise. It returns difference set.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_logical_but_operator.log
+.. select Entries --filter 'content @ "fast" &! content @ "mroonga"'
+
+The expression matches records that ``content`` column value has the
+word ``fast`` but doesn't have the word ``mroonga``.
+
+Bitwise operators
+^^^^^^^^^^^^^^^^^
+
+Here are bitwise operators.
+
+Bitwise NOT operator
+""""""""""""""""""""
+
+Its syntax is ``~number``.
+
+The operator returns bitwise NOT of ``number``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_bitwise_not_operator.log
+.. select Entries --filter '~n_likes == -6'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` because bitwise NOT of ``5`` is equal to ``-6``.
+
+Bitwise AND operator
+""""""""""""""""""""
+
+Its syntax is ``number1 & number2``.
+
+The operator returns bitwise AND between ``number1`` and ``number2``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_bitwise_and_operator.log
+.. select Entries --filter '(n_likes & 1) == 1'
+
+The expression matches records that ``n_likes`` column value is even
+number because bitwise AND between an even number and ``1`` is equal
+to ``1`` and bitwise AND between an odd number and ``1`` is equal to
+``0``.
+
+Bitwise OR operator
+^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``number1 | number2``.
+
+The operator returns bitwise OR between ``number1`` and ``number2``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_bitwise_or_operator.log
+.. select Entries --filter 'n_likes == (1 | 4)'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` (= ``1 | 4``).
+
+Bitwise XOR operator
+^^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``number1 ^ number2``.
+
+The operator returns bitwise XOR between ``number1`` and ``number2``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_bitwise_xor_operator.log
+.. select Entries --filter 'n_likes == (10 ^ 15)'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` (= ``10 ^ 15``).
+
+Shift operators
+^^^^^^^^^^^^^^^
+
+Here are shift operators.
+
+Left shift operator
+"""""""""""""""""""
+
+Its syntax is ``number1 << number2``.
+
+The operator performs a bitwise left shift operation on ``number1`` by
+``number2``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_left_shift_operator.log
+.. select Entries --filter 'n_likes == (5 << 1)'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``10`` (= ``5 << 1``).
+
+Signed right shift operator
+"""""""""""""""""""""""""""
+
+Its syntax is ``number1 >> number2``.
+
+The operator shifts bits of ``number1`` to right by ``number2``. The sign
+of the result is the same as ``number1``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_signed_right_shift_operator.log
+.. select Entries --filter 'n_likes == -(-10 >> 1)'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` (= ``-(-10 >> 1)`` = ``-(-5)``).
+
+Unsigned right shift operator
+"""""""""""""""""""""""""""""
+
+Its syntax is ``number1 >>> number2``.
+
+The operator shifts bits of ``number1`` to right by ``number2``. The
+leftmost ``number2`` bits are filled by ``0``.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_unsigned_right_shift_operator.log
+.. select Entries --filter 'n_likes == (2147483648 - (-10 >>> 1))'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5`` (= ``2147483648 - (-10 >>> 1)`` = ``2147483648 - 2147483643``).
+
+Comparison operators
+^^^^^^^^^^^^^^^^^^^^
+
+Here are comparison operators.
+
+Equal operator
+""""""""""""""
+
+Its syntax is ``object1 == object2``.
+
+The operator returns true if ``object1`` equals to ``object2``, false
+otherwise.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_equal_operator.log
+.. select Entries --filter 'n_likes == 5'
+
+The expression matches records that ``n_likes`` column value is equal
+to ``5``.
+
+Not equal operator
+""""""""""""""""""
+
+Its syntax is ``object1 != object2``.
+
+The operator returns true if ``object1`` does not equal to
+``object2``, false otherwise.
+
+Here is a simple example.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_not_equal_operator.log
+.. select Entries --filter 'n_likes != 5'
+
+The expression matches records that ``n_likes`` column value is not
+equal to ``5``.
+
+Less than operator
+""""""""""""""""""
+
+TODO: ...
+
+Less than or equal to operator
+""""""""""""""""""""""""""""""
+
+TODO: ...
+
+Greater than operator
+"""""""""""""""""""""
+
+TODO: ...
+
+Greater than or equal to operator
+"""""""""""""""""""""""""""""""""
+
+TODO: ...
+
+Assignment operators
+--------------------
+
+TODO: ...
+
+Original operators
+------------------
+
+Script syntax adds the original binary opearators to ECMAScript
+syntax. They operate search specific operations. They are starts with
+``@`` or ``*``.
+
+.. _match-oeprator:
+
+Match operator
+^^^^^^^^^^^^^^
+
+Its syntax is ``column @ value``.
+
+The operator searches ``value`` by inverted index of ``column``.
+Normally, full text search is operated but tag search can be operated.
+Because tag search is also implemented by inverted index.
+
+:doc:`query_syntax` uses this operator by default.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_match_operator.log
+.. select Entries --filter 'content @ "fast"' --output_columns content
+
+The expression matches records that contain a word ``fast`` in
+``content`` column value.
+
+.. _prefix-search-operator:
+
+Prefix search operator
+^^^^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``column @^ value``.
+
+The operator does prefix search with ``value``. Prefix search searches
+records that contain a word that starts with ``value``.
+
+You can use fast prefix search against a column. The column must be
+indexed and index table must be patricia trie table
+(``TABLE_PAT_KEY``) or double array trie table
+(``TABLE_DAT_KEY``). You can also use fast prefix search against
+``_key`` pseudo column of patricia trie table or double array trie
+table. You don't need to index ``_key``.
+
+Prefix search can be used with other table types but it causes all
+records scan. It's not problem for small records but it spends more
+time for large records.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_prefix_search_operator.log
+.. select Entries --filter '_key @^ "Goo"' --output_columns _key
+
+The expression matches records that contain a word that starts with
+``Goo`` in ``_key`` pseudo column value. ``Good-bye Senna`` and
+``Good-bye Tritonn`` are matched with the expression.
+
+.. _suffix-search-operator:
+
+Suffix search operator
+^^^^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``column @$ value``.
+
+This operator does suffix search with ``value``. Suffix search
+searches records that contain a word that ends with ``value``.
+
+You can use fast suffix search against a column. The column must be
+indexed and index table must be patricia trie table
+(``TABLE_PAT_KEY``) with ``KEY_WITH_SIS`` flag. You can also use fast
+suffix search against ``_key`` pseudo column of patricia trie table
+(``TABLE_PAT_KEY``) with ``KEY_WITH_SIS`` flag. You don't need to
+index ``_key``. We recommended that you use index column based fast
+suffix search instead of ``_key`` based fast suffix search. ``_key``
+based fast suffix search returns automatically registered
+substrings. (TODO: write document about suffix search and link to it
+from here.)
+
+.. note::
+
+   Fast suffix search can be used only for non-ASCII characters such
+   as hiragana in Japanese. You cannot use fast suffix search for
+   ASCII character.
+
+Suffix search can be used with other table types or patricia trie
+table without ``KEY_WITH_SIS`` flag but it causes all records
+scan. It's not problem for small records but it spends more time for
+large records.
+
+Here is a simple exmaple. It uses fast suffix search for hiragana in
+Japanese that is one of non-ASCII characters.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_suffix_search_operator.log
+.. table_create Titles TABLE_NO_KEY
+.. column_create Titles content COLUMN_SCALAR ShortText
+.. table_create SuffixSearchTerms TABLE_PAT_KEY|KEY_WITH_SIS ShortText
+.. column_create SuffixSearchTerms index COLUMN_INDEX Titles content
+.. load --table Titles
+.. [
+.. {"content": "ぐるんが"},
+.. {"content": "むるんが"},
+.. {"content": "せな"},
+.. {"content": "とりとん"}
+.. ]
+.. select Titles --query 'content:$んが'
+
+The expression matches records that have value that ends with ``んが``
+in ``content`` column value. ``ぐるんが`` and ``むるんが`` are matched
+with the expression.
+
+.. _near-search-operator:
+
+Near search operator
+^^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``column *N "word1 word2 ..."``.
+
+The operator does near search with words ``word1 word2 ...``. Near
+search searches records that contain the words and the words are
+appeared in the near distance. Near distance is always ``10`` for
+now. The unit of near distance is the number of characters in N-gram
+family tokenizers and the number of words in morphological analysis
+family tokenizers.
+
+(TODO: Add a description about ``TokenBigram`` doesn't split ASCII
+only word into tokens. So the unit for ASCII words with
+``TokenBigram`` is the number of words even if ``TokenBigram`` is a
+N-gram family tokenizer.)
+
+Note that an index column for full text search must be defined for
+``column``.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_near_search_operator.log
+.. select Entries --filter 'content *N "I fast"'      --output_columns content
+.. select Entries --filter 'content *N "I Really"'    --output_columns content
+.. select Entries --filter 'content *N "also Really"' --output_columns content
+
+The first expression matches records that contain ``I`` and ``fast``
+and the near distance of those words are in 10 words. So the record
+that its content is ``I also started to use mroonga. It's also very
+fast! ...`` is matched. The number of words between ``I`` and ``fast``
+is just 10.
+
+The second expression matches records that contain ``I`` and
+``Really`` and the near distance of those words are in 10 words. So
+the record that its content is ``I also started to use mroonga. It's
+also very fast! Really fast!`` is not matched. The number of words between
+``I`` and ``Really`` is 11.
+
+The third expression matches records that contain ``also`` and
+``Really`` and the near distance of those words are in 10 words. So
+the record that its content is ``I also st arted to use mroonga. It's
+also very fast! Really fast!`` is matched. The number of words between
+``also`` and ``Really`` is 10.
+
+.. _similar-search-operator:
+
+Similar search
+^^^^^^^^^^^^^^
+
+Its syntax is ``column *S "document"``.
+
+The operator does similar search with document ``document``. Similar
+search searches records that have similar content to
+``document``.
+
+Note that an index column for full text search must be defined for
+``column``.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_similar_search_operator.log
+.. select Entries --filter 'content *S "I migrated all Solr system!"' --output_columns content
+
+The expression matches records that have similar content to ``I
+migrated all Solr system!``. In this case, records that have ``I
+migrated all XXX system!`` content are matched.
+
+.. _term-extract-operator:
+
+Term extract operator
+^^^^^^^^^^^^^^^^^^^^^
+
+Its syntax is ``_key *T "document"``.
+
+The operator extracts terms from ``document``. Terms must be
+registered as keys of the table of ``_key``.
+
+Note that the table must be patricia trie (``TABLE_PAT_KEY``) or
+double array trie (``TABLE_DAT_KEY``). You can't use hash table
+(``TABLE_HASH_KEY``) and array (``TABLE_NO_KEY``) becuase they don't
+support longest common prefix search. Longest common prefix search is
+used to implement the operator.
+
+Here is a simple exmaple.
+
+.. groonga-command
+.. include:: ../../example/reference/grn_expr/script_syntax/simple_term_extract_operator.log
+.. table_create Words TABLE_PAT_KEY|KEY_NORMALIZE ShortText
+.. load --table Words
+.. [
+.. {"_key": "groonga"},
+.. {"_key": "mroonga"},
+.. {"_key": "Senna"},
+.. {"_key": "Tritonn"}
+.. ]
+.. select Words --filter '_key *T "Groonga is the successor project to Senna."' --output_columns _key
+
+The expression extrcts terms that included in document ``Groonga is
+the successor project to Senna.``. In this case, ``KEY_NORMALIZE``
+flag is specified to ``Words``. So ``Groonga`` can be extracted even
+if it is loaded as ``groonga`` into ``Words``. All of extracted terms
+are also normalized.