# -*- po -*-
# English translations for Groonga package.
# Copyright (C) 2009-2025 Groonga Project
# This file is distributed under the same license as the Groonga package.
# Automatically generated, 2025.
#
msgid ""
msgstr ""
"Project-Id-Version: Groonga 15.0.2\n"
"Report-Msgid-Bugs-To: \n"
"PO-Revision-Date: 2025-02-21 09:46+0000\n"
"Last-Translator: Automatically generated\n"
"Language-Team: none\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: en\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

msgid "Script syntax"
msgstr "Script syntax"

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Security"
msgstr "Security"

msgid "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."
msgstr "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."

msgid "Think about the following case."
msgstr "Think about the following case."

msgid "A Groonga application constructs a Groonga request by the following program::"
msgstr "A Groonga application constructs a Groonga request by the following program::"

msgid "``user_input`` is an input from user. If the input is ``query``, here is the constructed :ref:`select-filter` parameter::"
msgstr "``user_input`` is an input from user. If the input is ``query``, here is the constructed :ref:`select-filter` parameter::"

msgid "If the input is ``x\" || true || \"``, here is the constructed :ref:`select-filter` parameter::"
msgstr "If the input is ``x\" || true || \"``, here is the constructed :ref:`select-filter` parameter::"

msgid "This query matches to all records. The user will get all records from your database. The user may be evil."
msgstr "This query matches to all records. The user will get all records from your database. The user may be evil."

msgid "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."
msgstr "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."

msgid "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:"
msgstr "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:"

msgid "True value: Convert it to ``true``."
msgstr "True value: Convert it to ``true``."

msgid "False value: Convert it to ``false``."
msgstr "False value: Convert it to ``false``."

msgid "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."
msgstr "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."

msgid "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\"``."
msgstr "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\"``."

msgid "Sample data"
msgstr "Sample data"

msgid "Here are a schema definition and sample data to show usage."
msgstr "Here are a schema definition and sample data to show usage."

msgid "Execution example::"
msgstr "Execution example::"

msgid "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."
msgstr "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."

msgid "``Entries._key`` column and ``Entries.content`` column are indexed using ``TokenBigram`` tokenizer. So both ``Entries._key`` and ``Entries.content`` are fulltext search ready."
msgstr "``Entries._key`` column and ``Entries.content`` column are indexed using ``TokenBigram`` tokenizer. So both ``Entries._key`` and ``Entries.content`` are fulltext search ready."

msgid "OK. The schema and data for examples are ready."
msgstr "OK. The schema and data for examples are ready."

msgid "Literals"
msgstr "Literals"

msgid "Integer"
msgstr "Integer"

msgid "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."
msgstr "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."

msgid "The maximum value of integer literal is ``9223372036854775807`` (``= 2 ** 63 - 1``). The minimum value of integer literal is ``-9223372036854775808`` (``= -(2 ** 63)``)."
msgstr "The maximum value of integer literal is ``9223372036854775807`` (``= 2 ** 63 - 1``). The minimum value of integer literal is ``-9223372036854775808`` (``= -(2 ** 63)``)."

msgid "Float"
msgstr "Float"

msgid "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``."
msgstr "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``."

msgid "String"
msgstr "String"

msgid "String literal is ``\"...\"``. You need to escape ``\"`` in literal by prepending ``\\\\'' such as ``\\\"``. For example, ``\"Say \\\"Hello!\\\".\"`` is a literal for ``Say \"Hello!\".`` string."
msgstr "String literal is ``\"...\"``. You need to escape ``\"`` in literal by prepending ``\\\\'' such as ``\\\"``. For example, ``\"Say \\\"Hello!\\\".\"`` is a literal for ``Say \"Hello!\".`` string."

msgid "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."
msgstr "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."

msgid "Boolean"
msgstr "Boolean"

msgid "Boolean literal is ``true`` and ``false``. ``true`` means true and ``false`` means false."
msgstr "Boolean literal is ``true`` and ``false``. ``true`` means true and ``false`` means false."

msgid "Null"
msgstr "Null"

msgid "Null literal is ``null``. Groonga doesn't support null value but null literal is supported."
msgstr "Null literal is ``null``. Groonga doesn't support null value but null literal is supported."

msgid "Time"
msgstr "Time"

msgid "This is the groonga original notation."
msgstr "This is the groonga original notation."

msgid "Time literal doesn't exit. There are string time notation, integer time notation and float time notation."
msgstr "Time literal doesn't exit. There are string time notation, integer time notation and float time notation."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Geo point"
msgstr "Geo point"

msgid "Geo point literal doesn't exist. There is string geo point notation."
msgstr "Geo point literal doesn't exist. There is string geo point notation."

msgid "String geo point notation has the following patterns:"
msgstr "String geo point notation has the following patterns:"

msgid "``\"LATITUDE_IN_MSECxLONGITUDE_IN_MSEC\"``"
msgstr "``\"LATITUDE_IN_MSECxLONGITUDE_IN_MSEC\"``"

msgid "``\"LATITUDE_IN_MSEC,LONGITUDE_IN_MSEC\"``"
msgstr "``\"LATITUDE_IN_MSEC,LONGITUDE_IN_MSEC\"``"

msgid "``\"LATITUDE_IN_DEGREExLONGITUDE_IN_DEGREE\"``"
msgstr "``\"LATITUDE_IN_DEGREExLONGITUDE_IN_DEGREE\"``"

msgid "``\"LATITUDE_IN_DEGREE,LONGITUDE_IN_DEGREE\"``"
msgstr "``\"LATITUDE_IN_DEGREE,LONGITUDE_IN_DEGREE\"``"

msgid "``x`` and ``,`` can be used for separator. Latitude and longitude can be represented in milliseconds or degree."
msgstr "``x`` and ``,`` can be used for separator. Latitude and longitude can be represented in milliseconds or degree."

msgid "Array"
msgstr "Array"

msgid "Array literal is ``[element1, element2, ...]``."
msgstr "Array literal is ``[element1, element2, ...]``."

msgid "Object literal"
msgstr "Object literal"

msgid "Object literal is ``{name1: value1, name2: value2, ...}``. Groonga doesn't support object literal yet."
msgstr "Object literal is ``{name1: value1, name2: value2, ...}``. Groonga doesn't support object literal yet."

msgid "Control syntaxes"
msgstr "Control syntaxes"

msgid "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."
msgstr "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."

msgid "``A ? B : C`` returns ``B`` if ``A`` is true, ``C`` otherwise."
msgstr "``A ? B : C`` returns ``B`` if ``A`` is true, ``C`` otherwise."

msgid "Here is a simple example:"
msgstr "Here is a simple example:"

msgid "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``."
msgstr "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``."

msgid "Grouping"
msgstr "Grouping"

msgid "Its syntax is ``(...)``. ``...`` is comma separated expression list."
msgstr "Its syntax is ``(...)``. ``...`` is comma separated expression list."

msgid "``(...)`` 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."
msgstr "``(...)`` 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."

msgid "The first expression doesn't use grouping. It matches records that ``n_likes < 5`` and ``content @ \"senna\"`` are matched or ``content @ \"fast\"`` is matched."
msgstr "The first expression doesn't use grouping. It matches records that ``n_likes < 5`` and ``content @ \"senna\"`` are matched or ``content @ \"fast\"`` is matched."

msgid "The second expression uses grouping. It matches records that ``n_likes < 5`` and one of ``content @ \"senna\"`` or ``content @ \"fast\"`` are matched."
msgstr "The second expression uses grouping. It matches records that ``n_likes < 5`` and one of ``content @ \"senna\"`` or ``content @ \"fast\"`` are matched."

msgid "Function call"
msgstr "Function call"

msgid "Its syntax is ``name(arugment1, argument2, ...)``."
msgstr "Its syntax is ``name(arugment1, argument2, ...)``."

msgid "``name(argument1, argument2, ...)`` calls a function that is named ``name`` with arguments ``argument1``, ``argument2`` and ``...``."
msgstr "``name(argument1, argument2, ...)`` calls a function that is named ``name`` with arguments ``argument1``, ``argument2`` and ``...``."

msgid "See :doc:`/reference/function` for available functin list."
msgstr "See :doc:`/reference/function` for available functin list."

msgid "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."
msgstr "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."

msgid "Basic operators"
msgstr "Basic operators"

msgid "Groonga supports operators defined in ECMAScript."
msgstr "Groonga supports operators defined in ECMAScript."

msgid "Arithmetic operators"
msgstr "Arithmetic operators"

msgid "Here are arithmetic operators."
msgstr "Here are arithmetic operators."

msgid "Addition operator"
msgstr "Addition operator"

msgid "Its syntax is ``number1 + number2``."
msgstr "Its syntax is ``number1 + number2``."

msgid "The operator adds ``number1`` and ``number2`` and returns the result."
msgstr "The operator adds ``number1`` and ``number2`` and returns the result."

msgid "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``10 + 5``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``10 + 5``)."

msgid "Subtraction operator"
msgstr "Subtraction operator"

msgid "Its syntax is ``number1 - number2``."
msgstr "Its syntax is ``number1 - number2``."

msgid "The operator subtracts ``number2`` from ``number1`` and returns the result."
msgstr "The operator subtracts ``number2`` from ``number1`` and returns the result."

msgid "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``20 - 5``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``20 - 5``)."

msgid "Multiplication operator"
msgstr "Multiplication operator"

msgid "Its syntax is ``number1 * number2``."
msgstr "Its syntax is ``number1 * number2``."

msgid "The operator multiplies ``number1`` and ``number2`` and returns the result."
msgstr "The operator multiplies ``number1`` and ``number2`` and returns the result."

msgid "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``3 * 5``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``15`` (= ``3 * 5``)."

msgid "Division operator"
msgstr "Division operator"

msgid "Its syntax is ``number1 / number2`` and ``number1 % number2``."
msgstr "Its syntax is ``number1 / number2`` and ``number1 % number2``."

msgid "The operator divides ``number2`` by ``number1``. ``/`` returns the quotient of result. ``%`` returns the remainder of result."
msgstr "The operator divides ``number2`` by ``number1``. ``/`` returns the quotient of result. ``%`` returns the remainder of result."

msgid "Here is simple examples."
msgstr "Here is simple examples."

msgid "The expression matches records that ``n_likes`` column value is equal to ``3`` (= ``26 / 7``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``3`` (= ``26 / 7``)."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``26 % 7``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``26 % 7``)."

msgid "Logical operators"
msgstr "Logical operators"

msgid "Here are logical operators."
msgstr "Here are logical operators."

msgid "Logical NOT operator"
msgstr "Logical NOT operator"

msgid "Its syntax is ``!condition``."
msgstr "Its syntax is ``!condition``."

msgid "The operator inverts boolean value of ``condition``."
msgstr "The operator inverts boolean value of ``condition``."

msgid "The expression matches records that ``n_likes`` column value is not equal to ``5``."
msgstr "The expression matches records that ``n_likes`` column value is not equal to ``5``."

msgid "Logical AND operator"
msgstr "Logical AND operator"

msgid "Its syntax is ``condition1 && condition2``."
msgstr "Its syntax is ``condition1 && condition2``."

msgid "The operator returns true if both of ``condition1`` and ``condition2`` are true, false otherwise."
msgstr "The operator returns true if both of ``condition1`` and ``condition2`` are true, false otherwise."

msgid "The expression matches records that ``content`` column value has the word ``fast`` and ``n_likes`` column value is greater or equal to ``10``."
msgstr "The expression matches records that ``content`` column value has the word ``fast`` and ``n_likes`` column value is greater or equal to ``10``."

msgid "Logical OR operator"
msgstr "Logical OR operator"

msgid "Its syntax is ``condition1 || condition2``."
msgstr "Its syntax is ``condition1 || condition2``."

msgid "The operator returns true if either ``condition1`` or ``condition2`` is true, false otherwise."
msgstr "The operator returns true if either ``condition1`` or ``condition2`` is true, false otherwise."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` or ``10``."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` or ``10``."

msgid "Logical AND NOT operator"
msgstr "Logical AND NOT operator"

msgid "Its syntax is ``condition1 &! condition2``."
msgstr "Its syntax is ``condition1 &! condition2``."

msgid "The operator returns true if ``condition1`` is true but ``condition2`` is false, false otherwise. It returns difference set."
msgstr "The operator returns true if ``condition1`` is true but ``condition2`` is false, false otherwise. It returns difference set."

msgid "The expression matches records that ``content`` column value has the word ``fast`` but doesn't have the word ``mroonga``."
msgstr "The expression matches records that ``content`` column value has the word ``fast`` but doesn't have the word ``mroonga``."

msgid "Bitwise operators"
msgstr "Bitwise operators"

msgid "Here are bitwise operators."
msgstr "Here are bitwise operators."

msgid "Bitwise NOT operator"
msgstr "Bitwise NOT operator"

msgid "Its syntax is ``~number``."
msgstr "Its syntax is ``~number``."

msgid "The operator returns bitwise NOT of ``number``."
msgstr "The operator returns bitwise NOT of ``number``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` because bitwise NOT of ``5`` is equal to ``-6``."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` because bitwise NOT of ``5`` is equal to ``-6``."

msgid "Bitwise AND operator"
msgstr "Bitwise AND operator"

msgid "Its syntax is ``number1 & number2``."
msgstr "Its syntax is ``number1 & number2``."

msgid "The operator returns bitwise AND between ``number1`` and ``number2``."
msgstr "The operator returns bitwise AND between ``number1`` and ``number2``."

msgid "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``."
msgstr "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``."

msgid "Bitwise OR operator"
msgstr "Bitwise OR operator"

msgid "Its syntax is ``number1 | number2``."
msgstr "Its syntax is ``number1 | number2``."

msgid "The operator returns bitwise OR between ``number1`` and ``number2``."
msgstr "The operator returns bitwise OR between ``number1`` and ``number2``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``1 | 4``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``1 | 4``)."

msgid "Bitwise XOR operator"
msgstr "Bitwise XOR operator"

msgid "Its syntax is ``number1 ^ number2``."
msgstr "Its syntax is ``number1 ^ number2``."

msgid "The operator returns bitwise XOR between ``number1`` and ``number2``."
msgstr "The operator returns bitwise XOR between ``number1`` and ``number2``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``10 ^ 15``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``10 ^ 15``)."

msgid "Shift operators"
msgstr "Shift operators"

msgid "Here are shift operators."
msgstr "Here are shift operators."

msgid "Left shift operator"
msgstr "Left shift operator"

msgid "Its syntax is ``number1 << number2``."
msgstr "Its syntax is ``number1 << number2``."

msgid "The operator performs a bitwise left shift operation on ``number1`` by ``number2``."
msgstr "The operator performs a bitwise left shift operation on ``number1`` by ``number2``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``10`` (= ``5 << 1``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``10`` (= ``5 << 1``)."

msgid "Signed right shift operator"
msgstr "Signed right shift operator"

msgid "Its syntax is ``number1 >> number2``."
msgstr "Its syntax is ``number1 >> number2``."

msgid "The operator shifts bits of ``number1`` to right by ``number2``. The sign of the result is the same as ``number1``."
msgstr "The operator shifts bits of ``number1`` to right by ``number2``. The sign of the result is the same as ``number1``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``-(-10 >> 1)`` = ``-(-5)``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``-(-10 >> 1)`` = ``-(-5)``)."

msgid "Unsigned right shift operator"
msgstr "Unsigned right shift operator"

msgid "Its syntax is ``number1 >>> number2``."
msgstr "Its syntax is ``number1 >>> number2``."

msgid "The operator shifts bits of ``number1`` to right by ``number2``. The leftmost ``number2`` bits are filled by ``0``."
msgstr "The operator shifts bits of ``number1`` to right by ``number2``. The leftmost ``number2`` bits are filled by ``0``."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``2147483648 - (-10 >>> 1)`` = ``2147483648 - 2147483643``)."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5`` (= ``2147483648 - (-10 >>> 1)`` = ``2147483648 - 2147483643``)."

msgid "Comparison operators"
msgstr "Comparison operators"

msgid "Here are comparison operators."
msgstr "Here are comparison operators."

msgid "Equal operator"
msgstr "Equal operator"

msgid "Its syntax is ``object1 == object2``."
msgstr "Its syntax is ``object1 == object2``."

msgid "The operator returns true if ``object1`` equals to ``object2``, false otherwise."
msgstr "The operator returns true if ``object1`` equals to ``object2``, false otherwise."

msgid "The expression matches records that ``n_likes`` column value is equal to ``5``."
msgstr "The expression matches records that ``n_likes`` column value is equal to ``5``."

msgid "Not equal operator"
msgstr "Not equal operator"

msgid "Its syntax is ``object1 != object2``."
msgstr "Its syntax is ``object1 != object2``."

msgid "The operator returns true if ``object1`` does not equal to ``object2``, false otherwise."
msgstr "The operator returns true if ``object1`` does not equal to ``object2``, false otherwise."

msgid "Less than operator"
msgstr "Less than operator"

msgid "TODO: ..."
msgstr "TODO: ..."

msgid "Less than or equal to operator"
msgstr "Less than or equal to operator"

msgid "Greater than operator"
msgstr "Greater than operator"

msgid "Greater than or equal to operator"
msgstr "Greater than or equal to operator"

msgid "Assignment operators"
msgstr "Assignment operators"

msgid "Addition assignment operator"
msgstr "Addition assignment operator"

msgid "Its syntax is ``column1 += column2``."
msgstr "Its syntax is ``column1 += column2``."

msgid "The operator performs addition assignment operation on column1 by column2."
msgstr "The operator performs addition assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "For example, the value of ``_score`` about the record which stores \"Good-bye Senna\" as the ``_key`` is 3."
msgstr "For example, the value of ``_score`` about the record which stores \"Good-bye Senna\" as the ``_key`` is 3."

msgid "So the expression ``1 + 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 + 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Subtraction assignment operator"
msgstr "Subtraction assignment operator"

msgid "Its syntax is ``column1 -= column2``."
msgstr "Its syntax is ``column1 -= column2``."

msgid "The operator performs subtraction assignment operation on column1 by column2."
msgstr "The operator performs subtraction assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 - 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 - 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Multiplication assignment operator"
msgstr "Multiplication assignment operator"

msgid "Its syntax is ``column1 *= column2``."
msgstr "Its syntax is ``column1 *= column2``."

msgid "The operator performs multiplication assignment operation on column1 by column2."
msgstr "The operator performs multiplication assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 * 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 * 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Division assignment operator"
msgstr "Division assignment operator"

msgid "Its syntax is ``column1 /= column2``."
msgstr "Its syntax is ``column1 /= column2``."

msgid "The operator performs division assignment operation on column1 by column2."
msgstr "The operator performs division assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 / 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 / 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Modulo assignment operator"
msgstr "Modulo assignment operator"

msgid "Its syntax is ``column1 %= column2``."
msgstr "Its syntax is ``column1 %= column2``."

msgid "The operator performs modulo assignment operation on column1 by column2."
msgstr "The operator performs modulo assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 % 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 % 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Bitwise left shift assignment operator"
msgstr "Bitwise left shift assignment operator"

msgid "Its syntax is ``column1 <<= column2``."
msgstr "Its syntax is ``column1 <<= column2``."

msgid "The operator performs left shift assignment operation on column1 by column2."
msgstr "The operator performs left shift assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 << 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 << 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Bitwise signed right shift assignment operator"
msgstr "Bitwise signed right shift assignment operator"

msgid "Its syntax is ``column2 >>= column2``."
msgstr "Its syntax is ``column2 >>= column2``."

msgid "The operator performs signed right shift assignment operation on column1 by column2."
msgstr "The operator performs signed right shift assignment operation on column1 by column2."

msgid "Bitwise unsigned right shift assignment operator"
msgstr "Bitwise unsigned right shift assignment operator"

msgid "Its syntax is ``column1 >>>= column2``."
msgstr "Its syntax is ``column1 >>>= column2``."

msgid "The operator performs unsigned right shift assignment operation on column1 by column2."
msgstr "The operator performs unsigned right shift assignment operation on column1 by column2."

msgid "Bitwise AND assignment operator"
msgstr "Bitwise AND assignment operator"

msgid "Its syntax is ``column1 &= column2``."
msgstr "Its syntax is ``column1 &= column2``."

msgid "The operator performs bitwise AND assignment operation on column1 by column2."
msgstr "The operator performs bitwise AND assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "For example, the value of ``_score`` about the record which stores \"Groonga\" as the ``_key`` is 10."
msgstr "For example, the value of ``_score`` about the record which stores \"Groonga\" as the ``_key`` is 10."

msgid "So the expression ``1 & 10`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 & 10`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Bitwise OR assignment operator"
msgstr "Bitwise OR assignment operator"

msgid "Its syntax is ``column1 |= column2``."
msgstr "Its syntax is ``column1 |= column2``."

msgid "The operator performs bitwise OR assignment operation on column1 by column2."
msgstr "The operator performs bitwise OR assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 | 10`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 | 10`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Bitwise XOR assignment operator"
msgstr "Bitwise XOR assignment operator"

msgid "Its syntax is ``column1 ^= column2``."
msgstr "Its syntax is ``column1 ^= column2``."

msgid "The operator performs bitwise XOR assignment operation on column1 by column2."
msgstr "The operator performs bitwise XOR assignment operation on column1 by column2."

msgid "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."
msgstr "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."

msgid "So the expression ``1 ^ 3`` is evaluated and stored to ``_score`` column as the execution result."
msgstr "So the expression ``1 ^ 3`` is evaluated and stored to ``_score`` column as the execution result."

msgid "Original operators"
msgstr "Original operators"

msgid "Script syntax adds the original binary opearators to ECMAScript syntax. They operate search specific operations. They are starts with ``@`` or ``*``."
msgstr "Script syntax adds the original binary opearators to ECMAScript syntax. They operate search specific operations. They are starts with ``@`` or ``*``."

msgid "Match operator"
msgstr "Match operator"

msgid "Its syntax is ``column @ value``."
msgstr "Its syntax is ``column @ value``."

msgid "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."
msgstr "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."

msgid ":doc:`query_syntax` uses this operator by default."
msgstr ":doc:`query_syntax` uses this operator by default."

msgid "The expression matches records that contain a word ``fast`` in ``content`` column value."
msgstr "The expression matches records that contain a word ``fast`` in ``content`` column value."

msgid "Prefix search operator"
msgstr "Prefix search operator"

msgid "Its syntax is ``column @^ value``."
msgstr "Its syntax is ``column @^ value``."

msgid "The operator does prefix search with ``value``. Prefix search searches records that contain a word that starts with ``value``."
msgstr "The operator does prefix search with ``value``. Prefix search searches records that contain a word that starts with ``value``."

msgid "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``."
msgstr "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``."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Suffix search operator"
msgstr "Suffix search operator"

msgid "Its syntax is ``column @$ value``."
msgstr "Its syntax is ``column @$ value``."

msgid "This operator does suffix search with ``value``. Suffix search searches records that contain a word that ends with ``value``."
msgstr "This operator does suffix search with ``value``. Suffix search searches records that contain a word that ends with ``value``."

msgid "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.)"
msgstr "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.)"

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Here is a simple example. It uses fast suffix search for hiragana in Japanese that is one of non-ASCII characters."
msgstr "Here is a simple example. It uses fast suffix search for hiragana in Japanese that is one of non-ASCII characters."

msgid "The expression matches records that have value that ends with ``んが`` in ``content`` column value. ``ぐるんが`` and ``むるんが`` are matched with the expression."
msgstr "The expression matches records that have value that ends with ``んが`` in ``content`` column value. ``ぐるんが`` and ``むるんが`` are matched with the expression."

msgid "Near search operator"
msgstr "Near search operator"

msgid "Its syntax is one of them::"
msgstr "Its syntax is one of them::"

msgid "Here are the examples of the second form::"
msgstr "Here are the examples of the second form::"

msgid "The first example means that ``29`` is used for the max interval."
msgstr "The first example means that ``29`` is used for the max interval."

msgid "The second example means that ``-1`` is used for the max interval. ``-1`` max interval means no limit."
msgstr "The second example means that ``-1`` is used for the max interval. ``-1`` max interval means no limit."

msgid "Here are examples of the third form::"
msgstr "Here are examples of the third form::"

msgid "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."
msgstr "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."

msgid "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``."
msgstr "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``."

msgid "The max intervals of each token (word) are described later."
msgstr "The max intervals of each token (word) are described later."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "So the unit for ASCII words with ``TokenBigram`` is the number of words even if ``TokenBigram`` is a N-gram family tokenizer."
msgstr "So the unit for ASCII words with ``TokenBigram`` is the number of words even if ``TokenBigram`` is a N-gram family tokenizer."

msgid "Note that an index column for full text search must be defined for ``column``."
msgstr "Note that an index column for full text search must be defined for ``column``."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "The max intervals of each token."
msgstr "The max intervals of each token."

msgid "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."
msgstr "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."

msgid "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::"
msgstr "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::"

msgid "``10`` is the max interval."
msgstr "``10`` is the max interval."

msgid "``|`` is the separator of the max intervals of each token."
msgstr "``|`` is the separator of the max intervals of each token."

msgid "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``."
msgstr "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``."

msgid "Here is an example that specifies the max intervals of each token:"
msgstr "Here is an example that specifies the max intervals of each token:"

msgid "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."
msgstr "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."

msgid "Here is an example that omits an interval:"
msgstr "Here is an example that omits an interval:"

msgid "You can specify extra intervals. They are just ignored:"
msgstr "You can specify extra intervals. They are just ignored:"

msgid "Near phrase search operator"
msgstr "Near phrase search operator"

msgid "Here are examples of the second form::"
msgstr "Here are examples of the second form::"

msgid "The second example means that ``-1`` is used for the max interval."
msgstr "The second example means that ``-1`` is used for the max interval."

msgid "The max interval is described later."
msgstr "The max interval is described later."

msgid "The first example means that ``29`` is used for the additional last interval."
msgstr "The first example means that ``29`` is used for the additional last interval."

msgid "The second example means that ``-1`` is used for the additional last interval."
msgstr "The second example means that ``-1`` is used for the additional last interval."

msgid "The additional last interval is described later."
msgstr "The additional last interval is described later."

msgid "The max intervals of each phrase."
msgstr "The max intervals of each phrase."

msgid "Here are examples of the forth form::"
msgstr "Here are examples of the forth form::"

msgid "See :ref:`script-syntax-near-phrase-search-operator` for the max intervals of each phrase."
msgstr "See :ref:`script-syntax-near-phrase-search-operator` for the max intervals of each phrase."

msgid "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."
msgstr "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."

msgid "TODO: Use index that has ``TokenNgram(\"unify_alphabet\", false)`` tokenizer to show difference with near search with English text."
msgstr "TODO: Use index that has ``TokenNgram(\"unify_alphabet\", false)`` tokenizer to show difference with near search with English text."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Here is an example to use the custom max interval:"
msgstr "Here is an example to use the custom max interval:"

msgid "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."
msgstr "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."

msgid "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``."
msgstr "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``."

msgid "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 ``.$``."
msgstr "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 ``.$``."

msgid "Here is an example that uses ``-1`` as the additional last interval of the given phrases::"
msgstr "Here is an example that uses ``-1`` as the additional last interval of the given phrases::"

msgid "Here is an example to customize the additional last interval of the given phrases:"
msgstr "Here is an example to customize the additional last interval of the given phrases:"

msgid "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:"
msgstr "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:"

msgid "The interval between the first phrase and the second to last phrase is less than or equals to ``the max interval``."
msgstr "The interval between the first phrase and the second to last phrase is less than or equals to ``the max interval``."

msgid "The interval between the first phrase and the last phrase is less than or equals to ``the max interval`` + ``the additional last interval``."
msgstr "The interval between the first phrase and the last phrase is less than or equals to ``the max interval`` + ``the additional last interval``."

msgid "If you specify negative number as the additional last interval, the second condition isn't required. Appearing the last phrase is just needed."
msgstr "If you specify negative number as the additional last interval, the second condition isn't required. Appearing the last phrase is just needed."

msgid "Here is an example to use positive number as the additional last interval:"
msgstr "Here is an example to use positive number as the additional last interval:"

msgid "Near phrase product search operator"
msgstr "Near phrase product search operator"

msgid "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:"
msgstr "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:"

msgid "``a d``"
msgstr "``a d``"

msgid "``a e``"
msgstr "``a e``"

msgid "``b d``"
msgstr "``b d``"

msgid "``b e``"
msgstr "``b e``"

msgid "``c d``"
msgstr "``c d``"

msgid "``c e``"
msgstr "``c e``"

msgid "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."
msgstr "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."

msgid "This is more effective than multiple :ref:`script-syntax-near-phrase-search-operator` ."
msgstr "This is more effective than multiple :ref:`script-syntax-near-phrase-search-operator` ."

msgid "Ordered near phrase search operator"
msgstr "Ordered near phrase search operator"

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Ordered near phrase product search operator"
msgstr "Ordered near phrase product search operator"

msgid "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."
msgstr "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."

msgid "Similar search operator"
msgstr "Similar search operator"

msgid "Its syntax is ``column *S \"document\"``."
msgstr "Its syntax is ``column *S \"document\"``."

msgid "The operator does similar search with document ``document``. Similar search searches records that have similar content to ``document``."
msgstr "The operator does similar search with document ``document``. Similar search searches records that have similar content to ``document``."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Term extract operator"
msgstr "Term extract operator"

msgid "Its syntax is ``_key *T \"document\"``."
msgstr "Its syntax is ``_key *T \"document\"``."

msgid "The operator extracts terms from ``document``. Terms must be registered as keys of the table of ``_key``."
msgstr "The operator extracts terms from ``document``. Terms must be registered as keys of the table of ``_key``."

msgid "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."
msgstr "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."

msgid "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."
msgstr "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."

msgid "Regular expression operator"
msgstr "Regular expression operator"

msgid "Its syntax is ``column @~ \"pattern\"``."
msgstr "Its syntax is ``column @~ \"pattern\"``."

msgid "The operator searches records by the regular expression ``pattern``. If a record's ``column`` value is matched to ``pattern``, the record is matched."
msgstr "The operator searches records by the regular expression ``pattern``. If a record's ``column`` value is matched to ``pattern``, the record is matched."

msgid "``pattern`` must be valid regular expression syntax. See :doc:`/reference/regular_expression` about regular expression syntax details."
msgstr "``pattern`` must be valid regular expression syntax. See :doc:`/reference/regular_expression` about regular expression syntax details."

msgid "The following example uses ``.roonga`` as pattern. It matches ``Groonga``, ``Mroonga`` and so on."
msgstr "The following example uses ``.roonga`` as pattern. It matches ``Groonga``, ``Mroonga`` and so on."

msgid "In most cases, regular expression is evaluated sequentially. So it may be slow against many records."
msgstr "In most cases, regular expression is evaluated sequentially. So it may be slow against many records."

msgid "In some cases, Groonga evaluates regular expression by index. It's very fast. See :doc:`/reference/regular_expression` for details."
msgstr "In some cases, Groonga evaluates regular expression by index. It's very fast. See :doc:`/reference/regular_expression` for details."
