1.2.1 - en to ja translation catalogue (305 entries)

en: Execution example::
ja: 実行例::

en: Script syntax
ja: スクリプト構文

en: 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.
ja: スクリプト構文は複雑な検索条件を指定するための構文です。この構文はECMAScriptに似ています。例えば、 ``_key == "book"`` は ``_key`` の値が ``"book"`` のレコードを検索するという意味です。 :doc:`query_syntax` ではすべての値は文字列でしたが、スクリプト構文では値に型があります。例えば、 ``"book"`` は文字列で ``1`` は整数で、 ``TokenBigram`` は ``TokenBigram`` という名前のオブジェクトです。

en: 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.
ja: スクリプト構文はECMAScriptの構文と完全に互換性があるわけではありません。例えば、 ``if`` 制御文や ``for`` 繰り返し文や変数定義文といった文をサポートしていません。関数定義もサポートしていません。しかし、独自の演算子を追加しています。独自の演算子はECMAScriptの構文を説明した後に説明します。

en: Security
ja: セキュリティー

en: For security reason, you should not pass an input from users to Groonga directly. If there is an evil user, the user may input a query that retrieves records that should not be shown to the user.
ja: セキュリティーの観点からユーザーからの入力をそのままGroongaに渡すべきではありません。悪意のあるユーザーがそのユーザーには参照できてはいけないレコードを取得するクエリーを入力するかもしれないからです。

en: Think about the following case.
ja: 例えば、以下の状況を考えてみましょう。

en: A Groonga application constructs a Groonga request by the following program::
ja: あるGroongaアプリケーションがGroongaへのリクエストを次のようなプログラムで構築していたとします。::

en: ``user_input`` is an input from user. If the input is ``query``, here is the constructed :ref:`select-filter` parameter::
ja: ``user_input`` はユーザーからの入力です。入力が ``query`` だった場合は構築された :ref:`select-filter` 引数は次のようになります。::

en: If the input is ``x" || true || "``, here is the constructed :ref:`select-filter` parameter::
ja: もし、入力が ``x" || true || "`` だった場合は構築された :ref:`select-filter` 引数は次のようになります。::

en: This query matches to all records. The user will get all records from your database. The user may be evil.
ja: このクエリーはすべてのレコードにマッチします。このユーザーはデータベース中のすべてのレコードを取得するでしょう。このユーザーには悪意があったのかもしれません。

en: It's better that you just receive an user input as a value. It means that you don't accept that user input can contain operator such as ``@`` and ``&&``. If you accept operator, user can create evil query.
ja: ユーザーからの入力では値だけを受け取るようにする方がよいです。これは、ユーザーからの入力には ``@`` や ``&&`` のような演算子を受け付けないようにするということです。もし、演算子も受け付けるようにするなら、ユーザーは悪意のあるクエリーを作ることができます。

en: If user input has only value, you blocks evil query by escaping user input value. Here is a list how to escape user input value:
ja: ユーザーの入力が値だけなら、入力された値をエスケープすることで悪意のあるクエリーを防ぐことができます。以下はユーザーの入力をどのようにエスケープすればよいかのリストです。

en: True value: Convert it to ``true``.
ja: 真の値： ``true`` に変換してください。

en: False value: Convert it to ``false``.
ja: 負の値： ``false`` に変換してください。

en: Numerical value: Convert it to :ref:`script-syntax-literal-integer` or :ref:`script-syntax-literal-float`. For example, ``1.2``, ``-10``, ``314e-2`` and so on.
ja: 数値: :ref:`script-syntax-literal-integer` または :ref:`script-syntax-literal-float` に変換してください。例えば、 ``1.2`` 、 ``-10`` 、 ``314e-2`` といった具合です。

en: String value: Replace ``"`` with ``\"`` and ``\`` with ``\\`` in the string value and surround substituted string value by ``"``. For example, ``double " quote and back \ slash`` should be converted to ``"double \" quote and back \\ slash"``.
ja: 文字列：文字列中の ``"`` を ``\"`` で、 ``\`` を ``\\`` で置換してください。その後、置換した文字列を ``"`` で囲んでください。例えば、 ``double " quote and back \ slash`` は ``"double \" quote and back \\ slash"`` に変換します。

en: Sample data
ja: サンプルデータ

en: Here are a schema definition and sample data to show usage.
ja: 使い方を示すために使うスキーマ定義とサンプルデータは以下の通りです。

en: 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.
ja: ブログエントリ用の ``Entries`` テーブルがあります。各エントリはタイトルと内容と「いいね！」数を持っています。タイトルは ``Entries`` のキーとします。内容は ``Entries.content`` カラムの値とします。「いいね！」数は ``Entries.n_likes`` カラムの値とします。

en: ``Entries._key`` column and ``Entries.content`` column are indexed using ``TokenBigram`` tokenizer. So both ``Entries._key`` and ``Entries.content`` are fulltext search ready.
ja: ``Entries._key`` カラムと ``Entries.content`` カラムには ``TokenBigram`` トークナイザーを使ったインデックスを作成します。そのため、 ``Entries._key`` と ``Entries.content`` は両方とも全文検索できます。

en: OK. The schema and data for examples are ready.
ja: これで例を示すためのスキーマとデータの準備ができました。

en: Literals
ja: リテラル

en: Integer
ja: 整数

en: 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.
ja: 整数リテラルは ``1234567890`` のような ``0`` から ``9`` の並びです。 ``+29`` や ``-29`` のように符号として最初に ``+`` または ``-`` をつけることができます。整数リテラルは10進数です。8進数や16進数などは使えません。

en: The maximum value of integer literal is ``9223372036854775807`` (``= 2 ** 63 - 1``). The minimum value of integer literal is ``-9223372036854775808`` (``= -(2 ** 63)``).
ja: 整数リテラルの最大値は ``9223372036854775807`` （ ``= 2 ** 63 - 1`` ）です。最小値は ``-9223372036854775808`` （ ``= -(2 ** 63)`` ）です。

en: Float
ja: 浮動小数点数

en: 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``.
ja: 浮動小数点数リテラルは ``3.14`` のように、まず ``0`` から ``9`` 、次に ``.`` 、最後に ``0`` から ``9`` という並びです。 ``+3.14`` や ``-3.14`` のように符号として最初に ``+`` または ``-`` をつけることができます。 ``${基数}e${指数}`` や ``${基数}E${指数}`` というフォーマットもサポートしています。例えば、 ``314e-2`` は ``3.14`` と同じです。

en: String
ja: 文字列

en: String literal is ``"..."``. You need to escape ``"`` in literal by prepending ``\\'' such as ``\"``. For example, ``"Say \"Hello!\"."`` is a literal for ``Say "Hello!".`` string.
ja: 文字列リテラルは ``"..."`` です。リテラル中の ``"`` は ``\"`` というように ``\`` を前につけてエスケープします。例えば、 ``"Say \"Hello!\"."`` は ``Say "Hello!".`` という文字列のリテラルです。

en: 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.
ja: 文字列エンコーディングはデータベースのエンコーディングと合わせなければいけません。デフォルトのエンコーディングはUTF-8です。これは configure の ``--with-default-encoding`` オプションや :doc:`/reference/executables/groonga` の ``--encodiong`` などで変更できます。

en: Boolean
ja: 真偽値

en: Boolean literal is ``true`` and ``false``. ``true`` means true and ``false`` means false.
ja: 真偽値のリテラルは ``true`` と ``false`` です。 ``true`` は真という意味で、 ``false`` は偽という意味です。

en: Null
ja: NULL

en: Null literal is ``null``. Groonga doesn't support null value but null literal is supported.
ja: NULLのリテラルは ``null`` です。GroongaはNULL値をサポートしてませんが、NULLリテラルをサポートしています。

en: Time
ja: 時間

en: This is the groonga original notation.
ja: これはgroonga独自の記法です。

en: Time literal doesn't exit. There are string time notation, integer time notation and float time notation.
ja: 時間のリテラルはありません。文字列での時間記法、整数での時間記法または浮動小数点数での時間記法を使ってください。

en: 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.
ja: 文字列での時間記法は ``"YYYY/MM/DD hh:mm:ss.uuuuuu"`` または ``"YYYY-MM-DD hh:mm:ss.uuuuuu"`` です。 ``YYYY`` は西暦、 ``MM`` は月、 ``DD`` は日、 ``hh`` は時、 ``mm`` は分、 ``ss`` は秒、 ``uuuuuu`` はマイクロ秒です。ローカル時間です。例えば、 ``"2012/07/23 02:41:10.436218"`` はISO 8601形式では ``2012-07-23T02:41:10.436218`` になります。

en: 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.
ja: 整数での時間記法はUTC時間で1970年1月1日0時0分0秒からの経過秒数を使います。この時間はPOSIX時間とも呼ばれています。例えば、 ``1343011270`` はISO 8601形式では ``2012-07-23T02:41:10Z`` になります。

en: 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.
ja: 浮動小数点数での時間記法はUTC時間で1970年1月1日0時0分0秒からの経過秒数と経過マイクロ秒数を使います。例えば、 ``1343011270.436218`` はISO 8601形式では ``2012-07-23T02:41:10.346218Z`` になります。

en: Geo point
ja: 座標値

en: Geo point literal doesn't exist. There is string geo point notation.
ja: 座標値のリテラルはありません。文字列での座標値記法を使ってください。

en: String geo point notation has the following patterns:
ja: 文字列での座標値記法には以下のパターンがあります。

en: ``"LATITUDE_IN_MSECxLONGITUDE_IN_MSEC"``
ja: ``"ミリ秒表記の緯度xミリ秒表記の経度"``

en: ``"LATITUDE_IN_MSEC,LONGITUDE_IN_MSEC"``
ja: ``"ミリ秒表記の緯度,ミリ秒表記の経度"``

en: ``"LATITUDE_IN_DEGREExLONGITUDE_IN_DEGREE"``
ja: ``"度数表記の緯度x度数表記の経度"``

en: ``"LATITUDE_IN_DEGREE,LONGITUDE_IN_DEGREE"``
ja: ``"度数表記の緯度,度数表記の経度"``

en: ``x`` and ``,`` can be used for separator. Latitude and longitude can be represented in milliseconds or degree.
ja: ``x`` と ``,`` のどちらも区切り文字として使えます。緯度と経度はミリ秒または度数で指定します。

en: Array
ja: 配列

en: Array literal is ``[element1, element2, ...]``.
ja: 配列リテラルは ``[element1, element2, ...]`` です。

en: Object literal
ja: オブジェクトリテラル

en: Object literal is ``{name1: value1, name2: value2, ...}``. Groonga doesn't support object literal yet.
ja: オブジェクトのリテラルは ``{name1: value1, name2: value2, ...}`` です。groongaはまだオブジェクトリテラルをサポートしていません。

en: Control syntaxes
ja: 制御構文

en: 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.
ja: スクリプト構文は文をサポートしていません。そのため、 ``if`` のような制御文を使うことはできません。制御用の構文は ``A ? B : C`` 式だけ使うことができます。

en: ``A ? B : C`` returns ``B`` if ``A`` is true, ``C`` otherwise.
ja: ``A ? B : C`` は ``A`` が真なら ``B`` を返して、そうでなかったら ``C`` を返します。

en: Here is a simple example:
ja: 以下は簡単な使用例です。

en: 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``.
ja: この式は ``_id`` カラムの値が ``1`` で ``n_likes`` カラムの値が ``5`` または ``_id`` カラムの値が ``1`` ではなく ``n_likes`` カラムの値が ``3`` のレコードにマッチします。

en: Grouping
ja: グループ化

en: Its syntax is ``(...)``. ``...`` is comma separated expression list.
ja: 構文は ``(...)`` です。 ``...`` はカンマ区切りの式のリストです。

en: ``(...)`` 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.
ja: ``(...)`` は1つ以上の式をグループ化します。グループ化された式は1つの式として処理されます。 ``a && b || c`` は ``a`` と ``b`` の両方がマッチするか、 ``c`` がマッチすれば式全体がマッチする、という意味になります。 ``a && (b || c)`` は ``a`` がマッチして ``b`` と ``c`` はどちらか一方がマッチすれば式全体がマッチする、という意味になります。

en: The first expression doesn't use grouping. It matches records that ``n_likes < 5`` and ``content @ "senna"`` are matched or ``content @ "fast"`` is matched.
ja: 最初の式はグループ化していません。この式は ``n_likes < 5`` と ``content @ "senna"`` の両方がマッチするか ``content @ "fast"`` がマッチするレコードにマッチします。

en: The second expression uses grouping. It matches records that ``n_likes < 5`` and one of ``content @ "senna"`` or ``content @ "fast"`` are matched.
ja: 2番目の式はグループ化しています。この式は ``n_likes < 5`` にマッチして、 ``content @ "senna"`` と ``content @ "fast"`` は少なくともどちらか一方にマッチするレコードにマッチします。

en: Function call
ja: 関数呼び出し

en: Its syntax is ``name(arugment1, argument2, ...)``.
ja: 構文は ``name(arugment1, argument2, ...)`` です。

en: ``name(argument1, argument2, ...)`` calls a function that is named ``name`` with arguments ``argument1``, ``argument2`` and ``...``.
ja: ``name(argument1, argument2, ...)`` は ``name`` という関数を引数 ``argument1``, ``argument2``, ``...`` で呼び出します。

en: See :doc:`/reference/function` for available functin list.
ja: 利用可能な関数の一覧は :doc:`/reference/function` を参照してください。

en: 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.
ja: この式は :doc:`/reference/functions/edit_distance` を使っています。この式は ``_key`` カラムの値が ``"Groonga"`` に似ているレコードにマッチします。 ``"Groonga"`` との類似度は編集距離で計算します。編集距離が1文字以下なら似ているとします。この場合は ``"Groonga"`` と ``"Mroonga"`` が似ている値です。

en: Basic operators
ja: 基本的な演算子

en: Groonga supports operators defined in ECMAScript.
ja: groongaはECMAScriptで定義されている演算子をサポートしています。

en: Arithmetic operators
ja: 算術演算子

en: Here are arithmetic operators.
ja: 以下は算術演算子の説明です。

en: Addition operator
ja: 加算演算子

en: Its syntax is ``number1 + number2``.
ja: 構文は ``number1 + number2`` です。

en: The operator adds ``number1`` and ``number2`` and returns the result.
ja: この演算子は ``number1`` と ``number2`` を足した結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``10 + 5``).
ja: この式は ``n_likes`` カラムの値が ``15`` (= ``10 + 5``) のレコードにマッチします。

en: Subtraction operator
ja: 減算演算子

en: Its syntax is ``number1 - number2``.
ja: 構文は ``number1 - number2`` です。

en: The operator subtracts ``number2`` from ``number1`` and returns the result.
ja: この演算子は ``number2`` から ``number1`` を引いた結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``20 - 5``).
ja: この式は ``n_likes`` カラムの値が ``15`` (= ``20 - 5``) のレコードにマッチします。

en: Multiplication operator
ja: 乗算演算子

en: Its syntax is ``number1 * number2``.
ja: 構文は ``number1 * number2`` です。

en: The operator multiplies ``number1`` and ``number2`` and returns the result.
ja: この演算子は ``number1`` と ``number2`` を掛けた結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``3 * 5``).
ja: この式は ``n_likes`` カラムの値が ``15`` (= ``3 * 5``) のレコードにマッチします。

en: Division operator
ja: 除算演算子

en: Its syntax is ``number1 / number2`` and ``number1 % number2``.
ja: 構文は ``number1 / number2`` と ``number1 % number2`` です。

en: The operator divides ``number2`` by ``number1``. ``/`` returns the quotient of result. ``%`` returns the remainder of result.
ja: この演算子は ``number2`` を ``number1`` で割ります。 ``/`` は商を返します。 ``%`` は余りを返します。

en: Here is simple examples.
ja: 以下は簡単な使用例です。

en: The expression matches records that ``n_likes`` column value is equal to ``3`` (= ``26 / 7``).
ja: この式は ``n_likes`` カラムの値が ``3`` (= ``26 / 7``) のレコードにマッチします。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``26 % 7``).
ja: この式は ``n_likes`` カラムの値が ``5`` (= ``26 % 7``) の値にマッチします。

en: Logical operators
ja: 論理演算子

en: Here are logical operators.
ja: 以下は論理演算子の説明です。

en: Logical NOT operator
ja: 論理否定演算子

en: Its syntax is ``!condition``.
ja: 構文は ``!condition`` です。

en: The operator inverts boolean value of ``condition``.
ja: この演算子は ``condition`` の真偽値を反転します。

en: The expression matches records that ``n_likes`` column value is not equal to ``5``.
ja: この式は ``n_likes`` カラムの値が ``5`` ではない式にマッチします。

en: Logical AND operator
ja: 論理積演算子

en: Its syntax is ``condition1 && condition2``.
ja: 構文は ``condition1 && condition2`` です。

en: The operator returns true if both of ``condition1`` and ``condition2`` are true, false otherwise.
ja: この演算子は ``condition1`` と ``condition2`` の両方が真のときに真を返し、そうでなければ偽を返します。

en: The expression matches records that ``content`` column value has the word ``fast`` and ``n_likes`` column value is greater or equal to ``10``.
ja: この式は ``content`` カラムの値が ``fast`` を含んでいて、 ``n_likes`` カラムの値が ``10`` 以上のレコードにマッチします。

en: Logical OR operator
ja: 論理和演算子

en: Its syntax is ``condition1 || condition2``.
ja: 構文は ``condition1 || condition2`` です。

en: The operator returns true if either ``condition1`` or ``condition2`` is true, false otherwise.
ja: この演算子は ``condition1`` と ``condition2`` のどちらか一方が真のときに真を返し、そうでなければ偽を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` or ``10``.
ja: この式は ``n_likes`` カラムの値が ``5`` または ``10`` のレコードにマッチします。

en: Logical AND NOT operator
ja: 論理差演算子

en: Its syntax is ``condition1 &! condition2``.
ja: 構文は ``condition1 &! condition2`` です。

en: The operator returns true if ``condition1`` is true but ``condition2`` is false, false otherwise. It returns difference set.
ja: この演算子は ``condition1`` が真で ``condition2`` が偽のときに真を返し、そうでなければ偽を返します。差集合を返すということです。

en: The expression matches records that ``content`` column value has the word ``fast`` but doesn't have the word ``mroonga``.
ja: この式は ``content`` カラムの値が ``fast`` を含んでいるが ``mroonga`` を含んでいないレコードにマッチします。

en: Bitwise operators
ja: ビット演算子

en: Here are bitwise operators.
ja: 以下はビット演算子の説明です。

en: Bitwise NOT operator
ja: ビット否定演算子

en: Its syntax is ``~number``.
ja: 構文は ``~number`` です。

en: The operator returns bitwise NOT of ``number``.
ja: この演算子は ``number`` の各ビットを反転した結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` because bitwise NOT of ``5`` is equal to ``-6``.
ja: この式は ``n_likes`` カラムの値が ``5`` のレコードにマッチします。なぜならば、 ``5`` の各ビットを反転すると ``-6`` になるからです。

en: Bitwise AND operator
ja: ビット論理積演算子

en: Its syntax is ``number1 & number2``.
ja: 構文は ``number1 & number2`` です。

en: The operator returns bitwise AND between ``number1`` and ``number2``.
ja: この演算子は ``number1`` と ``number2`` をビット単位で論理積をした結果を返します。

en: 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``.
ja: この式は ``n_likes`` カラムの値が偶数のレコードにマッチします。なぜならば、偶数と ``1`` のビット単位の論理積は ``1`` になり、奇数と ``1`` のビット単位の論理積は ``0`` になるからです。

en: Bitwise OR operator
ja: ビット論理和演算子

en: Its syntax is ``number1 | number2``.
ja: 構文は ``number1 | number2`` です。

en: The operator returns bitwise OR between ``number1`` and ``number2``.
ja: この演算子は ``number1`` と ``number2`` をビット単位で論理和した結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``1 | 4``).
ja: この式は ``n_likes`` カラムの値が ``5`` (= ``1 | 4``) のレコードにマッチします。

en: Bitwise XOR operator
ja: ビット排他的論理和演算子

en: Its syntax is ``number1 ^ number2``.
ja: 構文は ``number1 ^ number2`` です。

en: The operator returns bitwise XOR between ``number1`` and ``number2``.
ja: この演算子は ``number1`` と ``number2`` をビット単位で排他的論理和した結果を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``10 ^ 15``).
ja: この式は ``n_likes`` カラムの値が ``5`` (= ``10 ^ 15``) の値にマッチします。

en: Shift operators
ja: シフト演算子

en: Here are shift operators.
ja: 以下はシフト演算子の説明です。

en: Left shift operator
ja: 左シフト演算子

en: Its syntax is ``number1 << number2``.
ja: 構文は ``number1 << number2`` です。

en: The operator performs a bitwise left shift operation on ``number1`` by ``number2``.
ja: この演算子は ``number1`` のビットを左に ``number2`` ビットシフトする。

en: The expression matches records that ``n_likes`` column value is equal to ``10`` (= ``5 << 1``).
ja: この式は ``n_likes`` カラムの値が ``10`` (= ``5 << 1``) のレコードにマッチします。

en: Signed right shift operator
ja: 符号付き右シフト演算子

en: Its syntax is ``number1 >> number2``.
ja: 構文は ``number1 >> number2`` です。

en: The operator shifts bits of ``number1`` to right by ``number2``. The sign of the result is the same as ``number1``.
ja: この演算子は ``number1`` のビットを右に ``number2`` ビットシフトします。結果の符号は ``number1`` の符号と同じです。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``-(-10 >> 1)`` = ``-(-5)``).
ja: この式は ``n_likes`` カラムの値が ``5`` (= ``-(-10 >> 1)`` = ``-(-5)``) のレコードにマッチします。

en: Unsigned right shift operator
ja: 符号なし右シフト演算子

en: Its syntax is ``number1 >>> number2``.
ja: 構文は ``number1 >>> number2`` です。

en: The operator shifts bits of ``number1`` to right by ``number2``. The leftmost ``number2`` bits are filled by ``0``.
ja: この演算子は ``number1`` のビットを右に ``number2`` ビットシフトします。一番左の ``number2`` ビットには ``0`` が入ります。

en: The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``2147483648 - (-10 >>> 1)`` = ``2147483648 - 2147483643``).
ja: この式は ``n_likes`` カラムの値が ``5`` (= ``2147483648 - (-10 >>> 1)`` = ``2147483648 - 2147483643``) のレコードにマッチします。

en: Comparison operators
ja: 比較演算子

en: Here are comparison operators.
ja: 以下は比較演算子の説明です。

en: Equal operator
ja: 等価演算子

en: Its syntax is ``object1 == object2``.
ja: 構文は ``object1 == object2`` です。

en: The operator returns true if ``object1`` equals to ``object2``, false otherwise.
ja: この演算子は ``object1`` が ``object2`` と等しいときは真を返し、そうでなければ偽を返します。

en: The expression matches records that ``n_likes`` column value is equal to ``5``.
ja: この式は ``n_likes`` カラムの値が ``5`` の値にマッチします。

en: Not equal operator
ja: 不等価演算子

en: Its syntax is ``object1 != object2``.
ja: 構文は ``object1 != object2`` です。

en: The operator returns true if ``object1`` does not equal to ``object2``, false otherwise.
ja: この演算子は ``object1`` が ``object2`` と等しくないときに真を返し、そうでなければ偽を返します。

en: Less than operator
ja: 小なり演算子

en: Less than or equal to operator
ja: 以下演算子

en: Greater than operator
ja: 大なり演算子

en: Greater than or equal to operator
ja: 以上演算子

en: Assignment operators
ja: 代入演算子

en: Addition assignment operator
ja: 加算代入演算子

en: Its syntax is ``column1 += column2``.
ja: 構文は ``column += value`` です。

en: The operator performs addition assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` を加算代入します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs addition assignment operation such as '_score = _score + n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score + n_likes' という加算代入演算をそれぞれのレコードへ適用します。

en: For example, the value of ``_score`` about the record which stores "Good-bye Senna" as the ``_key`` is 3.
ja: 例えば、 ``_key`` として"Good-bye Senna"を格納しているレコードの ``_score`` の値は3です。

en: So the expression ``1 + 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 + 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Subtraction assignment operator
ja: 減算代入演算子

en: Its syntax is ``column1 -= column2``.
ja: 構文は ``column1 -= column2`` です。

en: The operator performs subtraction assignment operation on column1 by column2.
ja: この演算子は ``column1`` から ``column2`` を減算代入します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score - n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score - n_likes' という減算代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 - 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 - 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Multiplication assignment operator
ja: 乗算代入演算子

en: Its syntax is ``column1 *= column2``.
ja: 構文は ``column1 *= column2`` です。

en: The operator performs multiplication assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` を乗算演算する。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score * n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score * n_likes' という乗算代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 * 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 * 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Division assignment operator
ja: 除算代入演算子

en: Its syntax is ``column1 /= column2``.
ja: 構文は ``column1 /= column2`` です。

en: The operator performs division assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` を除算代入します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score / n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score / n_likes' という除算代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 / 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 / 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Modulo assignment operator
ja: 剰余代入演算子

en: Its syntax is ``column1 %= column2``.
ja: 構文は ``column1 %= column2`` です。

en: The operator performs modulo assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` を剰余代入します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score % n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score % n_likes' という除算代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 % 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 % 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Bitwise left shift assignment operator
ja: 左シフト代入演算子

en: Its syntax is ``column1 <<= column2``.
ja: 構文は ``column1 << column2`` です。

en: The operator performs left shift assignment operation on column1 by column2.
ja: この演算子は ``column1`` のビットを左に ``column2`` 左ビットシフト代入演算します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score << n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score << n_likes' という左ビットシフト代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 << 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 << 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Bitwise signed right shift assignment operator
ja: 符号あり右シフト代入演算子

en: Its syntax is ``column2 >>= column2``.
ja: 構文は ``column1 >>= column2`` です。

en: The operator performs signed right shift assignment operation on column1 by column2.
ja: この演算子は ``column1`` のビットを ``column2`` 右ビットシフト代入演算します。

en: Bitwise unsigned right shift assignment operator
ja: 符号なし右シフト代入演算子

en: Its syntax is ``column1 >>>= column2``.
ja: 構文は ``column1 >>>= column2`` です。

en: The operator performs unsigned right shift assignment operation on column1 by column2.
ja: この演算子は ``column1`` のビットを ``column2`` 符号なし右ビットシフト代入演算します。

en: Bitwise AND assignment operator
ja: ビット論理積代入演算子

en: Its syntax is ``column1 &= column2``.
ja: 構文は ``column1 &= column2`` です。

en: The operator performs bitwise AND assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` をビット論理積代入演算します。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score & n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score & n_likes' というビット論理積代入演算をそれぞれのレコードへ適用します。

en: For example, the value of ``_score`` about the record which stores "Groonga" as the ``_key`` is 10.
ja: 例えば、 ``_key`` として"Groonga"を格納しているレコードの値は10です。

en: So the expression ``1 & 10`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 & 10`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Bitwise OR assignment operator
ja: ビット論理和代入演算子

en: Its syntax is ``column1 |= column2``.
ja: 構文は ``column1 |= column2`` です。

en: The operator performs bitwise OR assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` をビット論理和代入演算する。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score | n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score | n_likes' というビット論理和代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 | 10`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 | 10`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Bitwise XOR assignment operator
ja: ビット排他的論理和代入演算子

en: Its syntax is ``column1 ^= column2``.
ja: 構文は ``column1 ^= column2`` です。

en: The operator performs bitwise XOR assignment operation on column1 by column2.
ja: この演算子は ``column1`` に ``column2`` をビット論理和代入演算する。

en: The value of ``_score`` by ``--filter`` is always 1 in this case, then performs subtraction assignment operation such as '_score = _score ^ n_likes' for each records.
ja: ``--filter`` による ``_score`` の値はこの場合は常に1です。その後、'_score = _score ^ n_likes' という減算代入演算をそれぞれのレコードへ適用します。

en: So the expression ``1 ^ 3`` is evaluated and stored to ``_score`` column as the execution result.
ja: そのため、 ``1 ^ 3`` という式が評価されてから ``_score`` カラムへと演算結果が保存されます。

en: Original operators
ja: 独自の演算子

en: Script syntax adds the original binary opearators to ECMAScript syntax. They operate search specific operations. They are starts with ``@`` or ``*``.
ja: スクリプト構文はECMAScriptの構文に独自の二項演算子を追加しています。これらは検索に特化した操作をします。演算子の最初の文字は ``@`` または ``*`` です。

en: Match operator
ja: マッチ演算子

en: Its syntax is ``column @ value``.
ja: 構文は ``column @ value`` です。

en: 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.
ja: この演算子は ``column`` の転置インデックスを使って ``value`` を検索します。普通は全文検索をしますが、タグ検索もできます。これは、タグ検索も転置インデックスを使って実現しているからです。

en: :doc:`query_syntax` uses this operator by default.
ja: :doc:`query_syntax` はデフォルトでこの演算子を使っています。

en: The expression matches records that contain a word ``fast`` in ``content`` column value.
ja: この式は ``content`` カラムの値に ``fast`` という単語を含んでいるレコードにマッチします。

en: Prefix search operator
ja: 前方一致検索演算子

en: Its syntax is ``column @^ value``.
ja: 構文は ``column @^ value`` です。

en: The operator does prefix search with ``value``. Prefix search searches records that contain a word that starts with ``value``.
ja: この条件式は ``value`` で前方一致検索します。前方一致検索は ``value`` で始まる単語を含むレコードを検索します。

en: 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``.
ja: カラムの値を高速に前方一致検索できます。ただし、そのカラムにはインデックスを作成し、そのインデックス用のテーブルをパトリシアトライ（ ``TABLE_PAT_KEY`` ）またはダブル配列トライ（ ``TABLE_DAT_KEY`` ）にしなければいけません。あるいは、パトリシアトライテーブルまたはダブル配列テーブルの ``_key`` も高速に前方一致検索できます。 ``_key`` にインデックスを作成する必要はありません。

en: 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.
ja: 他の種類のテーブルでも前方一致検索を使えますがレコード全件を処理します。レコード数が少ない場合には問題ありませんが、レコード数が多いと時間がかかります。

en: 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.
ja: この式は ``_key`` カラムの値が ``Goo`` で始まる単語を含むレコードにマッチします。この式には ``Good-bye Senna`` と ``Good-bye Tritonn`` がマッチします。

en: Suffix search operator
ja: 後方一致検索演算子

en: Its syntax is ``column @$ value``.
ja: 構文は ``column @$ value`` です。

en: This operator does suffix search with ``value``. Suffix search searches records that contain a word that ends with ``value``.
ja: この演算子は ``value`` で後方一致検索します。後方一致検索は ``value`` で終わる単語を含むレコードを検索します。

en: 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.)
ja: カラムの値を高速に後方一致検索できます。ただし、そのカラムにはインデックスを作成し、そのインデックス用のテーブルを ``KEY_WITH_SIS`` フラグ付きのパトリシアトライテーブル（ ``TABLE_PAT_KEY`` ）にしなければいけません。 ``KEY_WITH_SIS`` フラグ付きのパトリシアトライテーブル（ ``TABLE_PAT_KEY`` ）の ``_key`` 擬似カラムの値も高速に後方一致検索できます。 ``_key`` にはインデックスを作成する必要はありません。 ``_key`` ベースの高速な後方一致検索よりもカラムベースの高速な後方一致検索を使うことをおすすめします。 ``_key`` ベースの高速な後方一致検索は自動的に登録された部分文字列も返ってきます。（TODO: 後方一致検索に関するドキュメントを書いてここからリンクを張る。）

en: 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.
ja: 高速な後方一致検索は日本語のひらがななど非ASCII文字にしか使えません。ASCII文字には高速な後方一致検索を使えません。

en: 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.
ja: 後方一致検索は他の種類のテーブルもしくはパトリシアトライを ``KEY_WITH_SIS`` フラグなしで使用しているテーブルに対しても使えますが、レコード全件を処理します。レコード数が少ない場合には問題ありませんが、レコード数が多いと時間がかかります。

en: Here is a simple example. It uses fast suffix search for hiragana in Japanese that is one of non-ASCII characters.
ja: 簡単な例です。ASCII文字ではない文字である日本語のひらがなに対して高速な後方一致検索をしています。

en: The expression matches records that have value that ends with ``んが`` in ``content`` column value. ``ぐるんが`` and ``むるんが`` are matched with the expression.
ja: この式は ``content`` カラムの値が ``んが`` で終わるレコードにマッチします。この場合は ``ぐるんが`` と ``むるんが`` にマッチします。

en: Near search operator
ja: 近傍検索演算子

en: Its syntax is one of them::
ja: 構文は以下のどれかです。::

en: Here are the examples of the second form::
ja: 2つめの形式の例は次の通りです。

en: The first example means that ``29`` is used for the max interval.
ja: 最初の例は近いと判断する最大距離として ``29`` を使うという意味です。

en: The second example means that ``-1`` is used for the max interval. ``-1`` max interval means no limit.
ja: 2つめの例は近いと判断する最大距離として ``-1`` を使うという意味です。 ``-1`` はどれだけ離れていてもよいという意味です。

en: Here are examples of the third form::
ja: 3つめの形式の例は次の通りです。

en: The first example means that ``2`` is used for the max interval of the first interval and ``3`` is used for the max interval of the second interval.
ja: 最初の例は最初のトークン間の最大距離として ``2`` を使い、2番目のトークン間の最大距離として ``3`` を使うという意味です。

en: The second example means that ``2`` is used for the first max interval of the first interval and ``-1`` is used for the max interval of the second interval. Because the omitted max interval is treated as ``-1``.
ja: 2番目の例は最初のトークン間の最大距離として ``2`` を使い、2番目のトークン間の最大距離として ``-1`` を使うという意味です。なぜなら省略された最大距離は ``-1`` として処理されるからです。

en: The max intervals of each token (word) are described later.
ja: トークン（単語）間の最大距離は後で説明します。

en: The operator does near search with words ``word1 word2 ...``. Near search searches records that contain the words and the words are appeared in the specified order and the max interval.
ja: この演算子は ``word1 word2 ...`` という単語で近傍検索します。近傍検索はすべての単語が含まれていてかつそれぞれが指定した順番で出現していてかつそれぞれの単語が指定した距離以内にあるレコードを検索します。

en: The max interval is ``10`` by default. The unit of the max interval is the number of characters in N-gram family tokenizers and the number of words in morphological analysis family tokenizers.
ja: 近いと判断する最大距離のデフォルトは ``10`` です。距離の単位はN-gram系のトークナイザーでは文字数で、形態素解析系のトークナイザーでは単語数です。

en: However, ``TokenBigram`` doesn't split ASCII only word into tokens. Because ``TokenBigram`` uses white-space-separate like tokenize method for ASCII characters in this case.
ja: しかし、``TokenBigram`` はASCIIだけの単語はトークンに分割しません。このケースでは、 ``TokenBigram`` はASCIIの文字には空白区切りのようなトークナイズ方法を使うためです。

en: So the unit for ASCII words with ``TokenBigram`` is the number of words even if ``TokenBigram`` is a N-gram family tokenizer.
ja: このため、 ``TokenBigram`` はN-gram系のトークナイザーですが、ASCIIだけの単語を扱う時の単位は単語数になります。

en: Note that an index column for full text search must be defined for ``column``.
ja: ``column`` 用の全文検索用インデックスカラムを定義しておく必要があることに注意してください。

en: The first expression matches records that contain ``I`` and ``fast`` and the max interval of those words are in 10 words. So the record that its content is ``I started to use Groonga. It's very fast!`` is matched. The number of words between ``I`` and ``fast`` is 7.
ja: 最初の式は ``I`` と ``fast`` が含まれていて、かつ、これらの単語が10単語以内近くにあるレコードにマッチします。そのため ``I started to use Groonga. It's very fast!`` にマッチします。 ``I`` と ``fast`` の間の単語数は7です。

en: The second expression matches records that contain ``I`` and ``Really`` and the max interval 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.
ja: 二番目の式は ``I`` と ``Really`` が含まれていて、かつ、これらの単語が10単語以内近くにあるレコードにマッチします。そのため、 ``I also st arted to use mroonga. It's also very fast! Really fast!`` はマッチしません。 ``I`` と ``Really`` の間の単語数は11です。

en: The third expression matches records that contain ``also`` and ``Really`` and the max interval 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.
ja: 三番目の式は ``also`` と ``Really`` が含まれていて、かつ、これらの単語が10単語以内近くにあるレコードにマッチします。そのため、 ``I also started to use mroonga. It's also very fast! Really fast!`` にマッチします。 ``also`` と ``Really`` の間の単語数は10です。

en: The max intervals of each token.
ja: 各トークン間の最大距離。

en: You can specify the max intervals of each token. The default is no limit. It means that all intervals of each token are valid as long as the max interval is satisfied.
ja: 各トークン間の最大距離を指定することができます。デフォルトでは制限はありません。これは全体の最大距離が満たされていれば各トークン間の距離は問わないということです。

en: Here is an example that use ``2`` for the max interval of the first interval and ``4`` for the max interval of the second interval::
ja: 以下は最初のトークン間の最大距離として ``2`` を使い、2番目のトークン間の最大距離として ``4`` を使う例です。::

en: ``10`` is the max interval.
ja: ``10`` は最大距離です。

en: ``|`` is the separator of the max intervals of each token.
ja: トークン間の最大距離は ``|`` で区切ります。

en: This matches ``a x b x x x c``. But this doesn't match ``a x x b c``, ``a b x x x x c`` and so on because the former has ``3`` interval for the first interval that is larger than ``2`` and the latter has ``5`` interval for the second interval that is later than ``4``.
ja: これは ``a x b x x x c`` にマッチします。しかし、これは ``a x x b c`` や ``a b x x x x c`` にはマッチしません。なぜなら、前者は最初のトークン間の距離が ``3`` で ``2`` より大きいからです。後者は2番目のトークン間の距離が ``5`` で ``4`` より大きいからです。

en: Here is an example that specifies the max intervals of each token:
ja: 以下は各トークン間の最大距離を指定する例です。

en: You can omit one or more intervals. Omitted intervals are treated as ``-1``. It means that ``*N11,5`` equals ``*N11,5|-1``. ``-1`` means that no limit.
ja: 1つ以上のトークン間の最大距離を省略することができます。省略されたトークン間の最大距離は ``-1`` として扱われます。これは ``*N11,5`` と ``*N11,5|-1`` は等しいということです。 ``-1`` は最大距離の制限がないという意味です。

en: Here is an example that omits an interval:
ja: 以下は1つのトークン間の最大距離を省略する例です。

en: You can specify extra intervals. They are just ignored:
ja: トークン間の最大距離を余分に指定することもできます。余分な最大距離は単に無視されます。

en: Near phrase search operator
ja: 近傍フレーズ検索演算子

en: Here are examples of the second form::
ja: 2つめの形式の例は次の通りです。

en: The second example means that ``-1`` is used for the max interval.
ja: 2つめの例は近いと判断する最大距離として ``-1`` を使うという意味です。

en: The max interval is described later.
ja: 最大距離は後で説明します。

en: The first example means that ``29`` is used for the additional last interval.
ja: 最初の例は最後の追加距離として ``29`` を使うという意味です。

en: The second example means that ``-1`` is used for the additional last interval.
ja: 2つめの例は最後の追加距離として ``-1`` を使うという意味です。

en: The additional last interval is described later.
ja: 最後の追加距離は後で説明します。

en: The max intervals of each phrase.
ja: 各フレーズ間の最大距離。

en: Here are examples of the forth form::
ja: 4つめの形式の例は次の通りです。

en: See :ref:`script-syntax-near-phrase-search-operator` for the max intervals of each phrase.
ja: 各フレーズ間の最大距離については :ref:`script-syntax-near-phrase-search-operator` を参照してください。

en: The operator does near phrase search with phrases ``phrase1 phrase2 ...``. Near phrase search searches records that contain the phrases and the phrases are appeared in the specified order and the max interval.
ja: この演算子は ``phrase1 phrase2 ...`` というフレーズで近傍フレーズ検索します。近傍フレーズ検索はすべてのフレーズが含まれていてかつそれぞれが指定した順番で出現していてかつそれぞれのフレーズが指定した距離以内にあるレコードを検索します。

en: The first expression matches records that contain ``I`` and ``fast`` and the max interval 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.
ja: 最初の式は ``I`` と ``fast`` が含まれていて、かつ、これらの単語が10単語以内近くにあるレコードにマッチします。そのため ``I also started to use mroonga. It's also very fast! ...`` にマッチします。 ``I`` と ``fast`` の間の単語数は10です。

en: The second expression matches records that contain ``I`` and ``Really`` and the max interval 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 14.
ja: 2番目の式は ``I`` と ``Really`` が含まれていて、かつ、これらの単語が10単語以内近くにあるレコードにマッチします。そのため、 ``I also started to use mroonga. It's also very fast! Really fast!`` はマッチしません。 ``I`` と ``Really`` の間の単語数は14です。

en: Here is an example to use the custom max interval:
ja: 以下は1つの最大距離をカスタマイズする例です。

en: The first expression matches ``I also started to use mroonga. It's also very fast! Really fast!`` because the number of words between ``I`` and ``Really`` is 14.
ja: 2番目の式は ``I also started to use mroonga. It's also very fast! Really fast!`` にマッチします。なぜなら ``I`` と ``Really`` の間の単語は14だからです。

en: The second expression also matches ``I also started to use mroonga. It's also very fast! Really fast!`` because ``-1`` means that there is no limitation the number of words between ``I`` and ``Really``.
ja: 2番目の式も ``I also started to use mroonga. It's also very fast! Really fast!`` にマッチします。なぜなら ``-1`` は ``I`` と ``Really`` の間にいくつ単語があってもよいという意味だからです。

en: You can use additional interval only for the last phrase. It means that you can accept more distance only between the second to last phrase and the last phrase. This is useful for implementing a near phrase search in the same sentence. If you specify ``.`` (sentence end phrase) as the last phrase and specify ``-1`` as the additional last interval, the other specified phrases must be appeared before ``.``. You must append ``$`` to the last phrase like ``.$``.
ja: 最後のフレーズにだけ距離を追加することができます。つまり、最後から2番目のフレーズと最後のフレーズの間だけより多くの距離を許容できるということです。これは同一文内での近傍フレーズ検索を実装するときに便利です。最後のフレーズとして ``。`` （文末のフレーズ）を指定し、最後の追加距離として ``-1`` を指定すると、 ``。`` の前に他のすべてのフレーズが出現しなければいけません。最後のフレーズには ``。$`` というように最後に ``$`` をつけなければいけません。

en: Here is an example that uses ``-1`` as the additional last interval of the given phrases::
ja: 以下は指定されたフレーズ群の最後の追加距離として ``-1`` を使う例です。::

en: Here is an example to customize the additional last interval of the given phrases:
ja: 以下は指定したフレーズ群の最後の追加距離をカスタマイズする例です。

en: You can also use positive number for the additional last interval. If you specify positive number as the additional last interval, all of the following conditions must be satisfied:
ja: 最後の追加距離に正の数を指定することもできます。最後の追加距離に正の数を指定した場合、次のすべての条件を満たす必要があります。

en: The interval between the first phrase and the second to last phrase is less than or equals to ``the max interval``.
ja: 最初のフレーズと最後から2番目のフレーズの距離は ``最大距離`` 以下でなければいけない。

en: The interval between the first phrase and the last phrase is less than or equals to ``the max interval`` + ``the additional last interval``.
ja: 最初のフレーズと最後のフレーズの距離は ``最大距離`` + ``最後の追加距離`` 以下でなければいけない。

en: If you specify negative number as the additional last interval, the second condition isn't required. Appearing the last phrase is just needed.
ja: 最後の追加距離に負の数を指定した場合は2番目の条件を満たさなくてもよいです。最後のフレーズが出現するだけでよいです。

en: Here is an example to use positive number as the additional last interval:
ja: 以下は最後の追加距離として正の数を指定する例です。

en: Near phrase product search operator
ja: 近傍フレーズ直積検索演算子

en: This operator does multiple :ref:`script-syntax-near-phrase-search-operator`. Phrases for each :ref:`script-syntax-near-phrase-search-operator` are computed as product of ``{phrase1_1, phrase1_2, ...}``, ``{phrase2_1, phrase2_2, ...}`` and ``...``. For example, ``column *NPP "(a b c) (d e)"`` uses the following phrases for near phrase searches:
ja: この演算子は複数の :ref:`script-syntax-near-phrase-search-operator` を使います。各 :ref:`script-syntax-near-phrase-search-operator` が使うフレーズ群は ``{フレーズ1-1, フレーズ1-2, ...}`` と ``{フレーズ2-1, フレーズ2-2, ...}`` と ``...`` の直積として計算します。たとえば、 ``column *NPP "(a b c) (d e)"`` は以下のフレーズ群のリストで近傍フレーズ検索をします。

en: You can use the all features of :ref:`script-syntax-near-phrase-search-operator` such as the max interval, ``$`` for the last phrase and the additional last interval.
ja: 最大距離や ``$`` による最後のフレーズ指定や最後の追加距離など :ref:`script-syntax-near-phrase-search-operator` のすべての機能を使うことができます。

en: This is more effective than multiple :ref:`script-syntax-near-phrase-search-operator` .
ja: これは複数の :ref:`script-syntax-near-phrase-search-operator` よりも効率的です。

en: Ordered near phrase search operator
ja: 順序付き近傍フレーズ検索演算子

en: This operator does ordered near phrase search with ``phrase1``, ``phrase2`` and ``...``. Ordered near phrase search is similar to :ref:`script-syntax-near-phrase-search-operator` but ordered near phrase search checks phrases order. For example, ``column *ONP "groonga mroonga pgroonga"`` matches ``groonga mroonga rroonga pgroonga`` but doesn't match ``groonga rroonga pgroonga mroonga``. Because the latter uses different order.
ja: この演算子は ``フレーズ1`` と ``フレーズ2`` と ``...`` で順序付き近傍フレーズ検索をします。順序付き近傍フレーズ検索は :ref:`script-syntax-near-phrase-search-operator` と似ていますが順序付き近傍フレーズ検索はフレーズの順番をチェックします。たとえば、 ``column *ONP "groonga mroonga pgroonga"`` は ``groonga mroonga rroonga pgroonga`` にマッチしますが ``groonga rroonga pgroonga mroonga`` にはマッチしません。なぜなら後者は順序が違うからです。

en: You can use the all features of :ref:`script-syntax-near-phrase-search-operator` such as the max interval and the additional last interval. But you don't need to specify ``$`` for the last phrase because the last phrase in query is the last phrase.
ja: 最大距離や最後の追加距離といった :ref:`script-syntax-near-phrase-search-operator` のすべての機能を使えます。しかし、最後のフレーズに ``$`` を指定する必要はありません。クエリー内の最後のフレーズが最後のフレーズになるからです。

en: Ordered near phrase product search operator
ja: 順序付き近傍フレーズ直積検索演算子

en: This operator does ordered near phrase product search. Ordered near phrase product search is similar to :ref:`script-syntax-near-phrase-product-search-operator` but ordered near phrase product search checks phrases order like :ref:`script-syntax-ordered-near-phrase-search-operator`. For example, ``column *ONPP "(a b c) (d e)"`` matches ``a 1 d`` but doesn't match ``d 1 a``. Because the latter uses different order.
ja: この演算子は順序付き近傍フレーズ直積検索をします。順序付き近傍フレーズ直積検索は :ref:`script-syntax-near-phrase-product-search-operator` と似ていますが、順序付き近傍フレーズ直積検索は :ref:`query-syntax-ordered-near-phrase-search-condition` のようにフレーズの順序をチェックします。たとえば、 ``column *ONPP "(a b c) (d e)"`` は ``a 1 d`` にマッチしますが、 ``d 1 a`` にはマッチしません。なぜなら後者は順序が違うからです。

en: Similar search operator
ja: 類似文書検索演算子

en: Its syntax is ``column *S "document"``.
ja: 構文は ``column *S "document"`` です。

en: The operator does similar search with document ``document``. Similar search searches records that have similar content to ``document``.
ja: この演算子は ``document`` という文書で類似文書検索します。類似文書検索は ``document`` と似た内容を持つレコードを検索します。

en: 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.
ja: この式は ``I migrated all Solr system!`` と似た内容を持つレコードを検索します。この場合は、 ``I migrated all XXX system!`` という内容のレコードがマッチします。

en: You should use ``TokenMecab`` tokenizer for similar search against Japanese documents. Because ``TokenMecab`` will tokenize target documents to almost words, it improves similar search precision.
ja: 日本語の文書に対して類似文書検索を行う場合は、 ``TokenMecab`` を使う方が良いです。``TokenMecab`` は、対象の文書をほぼ単語にトークナイズするので、類似文書検索の精度が向上するためです。

en: Term extract operator
ja: 単語抽出演算子

en: Its syntax is ``_key *T "document"``.
ja: 構文は ``_key *T "document"`` です。

en: The operator extracts terms from ``document``. Terms must be registered as keys of the table of ``_key``.
ja: この演算子は ``document`` から単語を抽出します。単語は ``_key`` のテーブルのキーとして登録されていなければいけません。

en: 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``) because they don't support longest common prefix search. Longest common prefix search is used to implement the operator.
ja: テーブルはパトリシアトライ（ ``TABLE_PAT_KEY`` ）またはダブル配列トライ（ ``TABLE_DAT_KEY`` ）でなければいけません。ハッシュテーブル（ ``TABLE_HASH_KEY`` ）や配列（ ``TABLE_NO_KEY`` ）は最長共通接頭辞検索（Longest Common Prefix Search）できないため使えません。この演算子は最長共通接頭辞検索を使っています。

en: The expression extrcts terms that included in document ``Groonga is the successor project to Senna.``. In this case, ``NormalizerAuto`` normalizer 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.
ja: この式は文書 ``Groonga is the successor project to Senna.`` に含まれている単語を抽出します。今回は ``Words`` に ``NormalizerAuto`` ノーマライザーが指定されています。そのため、 ``Words`` には ``groonga`` とロードしていますが ``Groonga`` も抽出できています。また、すべてての抽出された単語も正規化されています。

en: Regular expression operator
ja: 正規表現演算子

en: Its syntax is ``column @~ "pattern"``.
ja: 構文は ``column @~ "pattern"`` です。

en: The operator searches records by the regular expression ``pattern``. If a record's ``column`` value is matched to ``pattern``, the record is matched.
ja: この演算子は正規表現 ``pattern`` でレコードを検索します。もし、レコードの ``column`` の値が ``pattern`` にマッチしたら、そのレコードはマッチしたということです。

en: ``pattern`` must be valid regular expression syntax. See :doc:`/reference/regular_expression` about regular expression syntax details.
ja: ``pattern`` は正規表現の構文になっていなければいけません。正規表現の構文の詳細は :doc:`/reference/regular_expression` を参照してください。

en: The following example uses ``.roonga`` as pattern. It matches ``Groonga``, ``Mroonga`` and so on.
ja: 以下の例はパターンとして ``.roonga`` を使っています。このパターンは ``Groonga`` 、 ``Mroonga`` といった文字列にマッチします。

en: In most cases, regular expression is evaluated sequentially. So it may be slow against many records.
ja: 多くの場合、各レコードに対して順に正規表現を評価します。そのため、多くのレコードがある場合は遅くなるかもしれません。

en: In some cases, Groonga evaluates regular expression by index. It's very fast. See :doc:`/reference/regular_expression` for details.
ja: いくつかのケースでは、Groongaはインデックスを使って正規表現を評価します。これはとても高速です。詳細は :doc:`/reference/regular_expression` を参照してください。
