# -*- 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 "Regular expression"
msgstr "Regular expression"

msgid "Summary"
msgstr "Summary"

msgid "Regular expression support is an experimental feature."
msgstr "Regular expression support is an experimental feature."

msgid "Groonga supports pattern match by regular expression. Regular expression is widely used format to describe a pattern. Regular expression is useful to represent complex pattern."
msgstr "Groonga supports pattern match by regular expression. Regular expression is widely used format to describe a pattern. Regular expression is useful to represent complex pattern."

msgid "In most cases, pattern match by regular expression is evaluated as sequential search. It'll be slow for many records and many texts."
msgstr "In most cases, pattern match by regular expression is evaluated as sequential search. It'll be slow for many records and many texts."

msgid "In some cases, pattern match by regular expression can be evaluated by index. It's very fast rather than sequential search. Patterns that can be evaluated by index are described later."
msgstr "In some cases, pattern match by regular expression can be evaluated by index. It's very fast rather than sequential search. Patterns that can be evaluated by index are described later."

msgid "Groonga normalizes match target text by :ref:`normalizer-auto` normalizer when Groonga doesn't use index for regular expression search. It means that regular expression that has upper case such as ``Groonga`` never match. Because :ref:`normalizer-auto` normalizer normalizes all alphabets to lower case. ``groonga`` matches to both ``Groonga`` and ``groonga``."
msgstr "Groonga normalizes match target text by :ref:`normalizer-auto` normalizer when Groonga doesn't use index for regular expression search. It means that regular expression that has upper case such as ``Groonga`` never match. Because :ref:`normalizer-auto` normalizer normalizes all alphabets to lower case. ``groonga`` matches to both ``Groonga`` and ``groonga``."

msgid "Why is match target text normalizered? It's for increasing index search-able patterns. If Groonga doesn't normalize match target text, you need to write complex regular expression such as ``[Dd][Ii][Ss][Kk]`` and ``(?i)disk`` for case-insensitive match. Groonga can't use index against complex regular expression."
msgstr "Why is match target text normalizered? It's for increasing index search-able patterns. If Groonga doesn't normalize match target text, you need to write complex regular expression such as ``[Dd][Ii][Ss][Kk]`` and ``(?i)disk`` for case-insensitive match. Groonga can't use index against complex regular expression."

msgid "If you write ``disk`` regular expression for case-insensitive match, Groonga can search the pattern with index. It's fast."
msgstr "If you write ``disk`` regular expression for case-insensitive match, Groonga can search the pattern with index. It's fast."

msgid "By full text search normally, Groonga normalize search keywords using the normalizer specified in a lexicon. By using regular expression search, Groonga doesn't normalize search keywords. Because the regular expression has specified meaning in uppercase and lowercase."
msgstr "By full text search normally, Groonga normalize search keywords using the normalizer specified in a lexicon. By using regular expression search, Groonga doesn't normalize search keywords. Because the regular expression has specified meaning in uppercase and lowercase."

msgid "So, if you regular expression search that doesn't use the index, we suggest that use :doc:`/reference/commands/normalize` command to normalize search keywords before a search. By using :doc:`/reference/commands/normalize` command, you don't have to need to think about how to normalize search keywords."
msgstr "So, if you regular expression search that doesn't use the index, we suggest that use :doc:`/reference/commands/normalize` command to normalize search keywords before a search. By using :doc:`/reference/commands/normalize` command, you don't have to need to think about how to normalize search keywords."

msgid "You may feel the behavior is strange. But fast search based on this behavior will help you."
msgstr "You may feel the behavior is strange. But fast search based on this behavior will help you."

msgid "There are many regular expression syntaxes. Groonga uses the same syntax in Ruby. Because Groonga uses the same regular expression engine as Ruby. The regular expression engine is `Onigmo <https://github.com/k-takata/Onigmo/>`_. Characteristic difference with other regular expression syntax is ``^`` and ``$``. The regular expression syntax in Ruby, ``^`` means the beginning of line and ``$`` means the end of line. ``^`` means the beginning of text and ``$`` means the end of text in other most regular expression syntaxes. The regular expression syntax in Ruby uses ``\\A`` for the beginning of text and ``\\z`` for the end of text."
msgstr "There are many regular expression syntaxes. Groonga uses the same syntax in Ruby. Because Groonga uses the same regular expression engine as Ruby. The regular expression engine is `Onigmo <https://github.com/k-takata/Onigmo/>`_. Characteristic difference with other regular expression syntax is ``^`` and ``$``. The regular expression syntax in Ruby, ``^`` means the beginning of line and ``$`` means the end of line. ``^`` means the beginning of text and ``$`` means the end of text in other most regular expression syntaxes. The regular expression syntax in Ruby uses ``\\A`` for the beginning of text and ``\\z`` for the end of text."

msgid "Groonga uses multiline mode since 5.0.6. It means that ``.`` matches on ``\\n``."
msgstr "Groonga uses multiline mode since 5.0.6. It means that ``.`` matches on ``\\n``."

msgid "But it's meaningless. Because ``\\n`` is removed by :ref:`normalizer-auto` normalizer."
msgstr "But it's meaningless. Because ``\\n`` is removed by :ref:`normalizer-auto` normalizer."

msgid "You can use regular expression in :ref:`select-query` and :ref:`select-filter` options of :doc:`/reference/commands/select` command."
msgstr "You can use regular expression in :ref:`select-query` and :ref:`select-filter` options of :doc:`/reference/commands/select` command."

msgid "Usage"
msgstr "Usage"

msgid "Here are a schema definition and sample data to show usage. There is only one table, ``Logs``. ``Logs`` table has only ``message`` column. Log messages are stored into the ``message`` column."
msgstr "Here are a schema definition and sample data to show usage. There is only one table, ``Logs``. ``Logs`` table has only ``message`` column. Log messages are stored into the ``message`` column."

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

msgid "Here is an example that uses regular expression in :ref:`select-query`. You need to use ``${COLUMN}:~${REGULAR_EXPRESSION}`` syntax."
msgstr "Here is an example that uses regular expression in :ref:`select-query`. You need to use ``${COLUMN}:~${REGULAR_EXPRESSION}`` syntax."

msgid "Here is an example that uses regular expression in :ref:`select-filter`. You need to use ``${COLUMN} @~ ${REGULAR_EXPRESSION}`` syntax."
msgstr "Here is an example that uses regular expression in :ref:`select-filter`. You need to use ``${COLUMN} @~ ${REGULAR_EXPRESSION}`` syntax."

msgid "Index"
msgstr "Index"

msgid "Groonga can search records by regular expression with index. It's very fast rather than sequential search."
msgstr "Groonga can search records by regular expression with index. It's very fast rather than sequential search."

msgid "But it doesn't support all regular expression patterns. It supports only the following regular expression patterns. The patterns will be increased in the future."
msgstr "But it doesn't support all regular expression patterns. It supports only the following regular expression patterns. The patterns will be increased in the future."

msgid "Literal only pattern such as ``disk``"
msgstr "Literal only pattern such as ``disk``"

msgid "The begging of text and literal only pattern such as ``\\Adisk``"
msgstr "The begging of text and literal only pattern such as ``\\Adisk``"

msgid "The end of text and literal only pattern such as ``disk\\z``"
msgstr "The end of text and literal only pattern such as ``disk\\z``"

msgid "You need to create an index for fast regular expression search. Here are requirements of index:"
msgstr "You need to create an index for fast regular expression search. Here are requirements of index:"

msgid "Lexicon must be :ref:`table-pat-key` table."
msgstr "Lexicon must be :ref:`table-pat-key` table."

msgid "Lexicon must use :ref:`token-regexp` tokenizer."
msgstr "Lexicon must use :ref:`token-regexp` tokenizer."

msgid "Index column must has ``WITH_POSITION`` flag."
msgstr "Index column must has ``WITH_POSITION`` flag."

msgid "Other configurations such as lexicon's normalizer are optional. You can choose what you like. If you want to use case-insensitive search, use :ref:`normalizer-auto` normalizer."
msgstr "Other configurations such as lexicon's normalizer are optional. You can choose what you like. If you want to use case-insensitive search, use :ref:`normalizer-auto` normalizer."

msgid "Here are recommended index definitions. In general, it's reasonable index definitions."
msgstr "Here are recommended index definitions. In general, it's reasonable index definitions."

msgid "Now, you can use index for regular expression search. The following regular expression can be evaluated by index because it uses only \"the beginning of text\" and \"literal\"."
msgstr "Now, you can use index for regular expression search. The following regular expression can be evaluated by index because it uses only \"the beginning of text\" and \"literal\"."

msgid "Here is an example that uses :ref:`select-filter` instead of :ref:`select-query`. It uses the same regular expression as the previous example."
msgstr "Here is an example that uses :ref:`select-filter` instead of :ref:`select-query`. It uses the same regular expression as the previous example."

msgid "``\\`` escape will confuse you because there are some steps that require escape between you and Groonga. Here are steps that require ``\\`` escape:"
msgstr "``\\`` escape will confuse you because there are some steps that require escape between you and Groonga. Here are steps that require ``\\`` escape:"

msgid "Shell only when you pass Groonga command from command line the following::"
msgstr "Shell only when you pass Groonga command from command line the following::"

msgid "``--filter '\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"'`` is evaluated as the following two arguments by shell:"
msgstr "``--filter '\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"'`` is evaluated as the following two arguments by shell:"

msgid "``--filter``"
msgstr "``--filter``"

msgid "``\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"``"
msgstr "``\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"``"

msgid "Groonga command parser only when you pass Groonga command by command line style (``COMMAND ARG1_VALUE ARG2_VALUE ...``) not HTTP path style (``/d/COMMAND?ARG1_NAME=ARG1_VALUE&ARG2_NAME=ARG3_VALUE``)."
msgstr "Groonga command parser only when you pass Groonga command by command line style (``COMMAND ARG1_VALUE ARG2_VALUE ...``) not HTTP path style (``/d/COMMAND?ARG1_NAME=ARG1_VALUE&ARG2_NAME=ARG3_VALUE``)."

msgid "``\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"`` is evaluated as the following value by Groonga command parser:"
msgstr "``\"message @~ \\\"\\\\\\\\Ahost1:\\\"\"`` is evaluated as the following value by Groonga command parser:"

msgid "``message @~ \"\\\\Ahost1:\"``"
msgstr "``message @~ \"\\\\Ahost1:\"``"

msgid ":doc:`/reference/grn_expr` parser. ``\\`` escape is required in both :doc:`/reference/grn_expr/query_syntax` and :doc:`/reference/grn_expr/script_syntax`."
msgstr ":doc:`/reference/grn_expr` parser. ``\\`` escape is required in both :doc:`/reference/grn_expr/query_syntax` and :doc:`/reference/grn_expr/script_syntax`."

msgid "``\"\\\\Ahost1:\"`` string literal in script syntax is evaluated as the following value:"
msgstr "``\"\\\\Ahost1:\"`` string literal in script syntax is evaluated as the following value:"

msgid "``\\Ahost1``"
msgstr "``\\Ahost1``"

msgid "The value is evaluated as regular expression."
msgstr "The value is evaluated as regular expression."

msgid "Syntax"
msgstr "Syntax"

msgid "This section describes about only commonly used syntaxes. See `Onigmo syntax documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE>`_ for other syntaxes and details."
msgstr "This section describes about only commonly used syntaxes. See `Onigmo syntax documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE>`_ for other syntaxes and details."

msgid "Escape"
msgstr "Escape"

msgid "In regular expression, there are the following special characters:"
msgstr "In regular expression, there are the following special characters:"

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

msgid "``|``"
msgstr "``|``"

msgid "``(``"
msgstr "``(``"

msgid "``)``"
msgstr "``)``"

msgid "``[``"
msgstr "``[``"

msgid "``]``"
msgstr "``]``"

msgid "``.``"
msgstr "``.``"

msgid "``*``"
msgstr "``*``"

msgid "``+``"
msgstr "``+``"

msgid "``?``"
msgstr "``?``"

msgid "``{``"
msgstr "``{``"

msgid "``}``"
msgstr "``}``"

msgid "``^``"
msgstr "``^``"

msgid "``$``"
msgstr "``$``"

msgid "If you want to write pattern that matches these special character as is, you need to escape them."
msgstr "If you want to write pattern that matches these special character as is, you need to escape them."

msgid "You can escape them by putting ``\\`` before special character. Here are regular expressions that match special character itself:"
msgstr "You can escape them by putting ``\\`` before special character. Here are regular expressions that match special character itself:"

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

msgid "``\\|``"
msgstr "``\\|``"

msgid "``\\(``"
msgstr "``\\(``"

msgid "``\\)``"
msgstr "``\\)``"

msgid "``\\[``"
msgstr "``\\[``"

msgid "``\\]``"
msgstr "``\\]``"

msgid "``\\.``"
msgstr "``\\.``"

msgid "``\\*``"
msgstr "``\\*``"

msgid "``\\+``"
msgstr "``\\+``"

msgid "``\\?``"
msgstr "``\\?``"

msgid "``\\{``"
msgstr "``\\{``"

msgid "``\\}``"
msgstr "``\\}``"

msgid "``\\^``"
msgstr "``\\^``"

msgid "``\\$``"
msgstr "``\\$``"

msgid "If your regular expression doesn't work as you expected, confirm that some special characters are used without escaping."
msgstr "If your regular expression doesn't work as you expected, confirm that some special characters are used without escaping."

msgid "Choice"
msgstr "Choice"

msgid "Choice syntax is ``A|B``. The regular expression matches when either ``A`` pattern or ``B`` pattern is matched."
msgstr "Choice syntax is ``A|B``. The regular expression matches when either ``A`` pattern or ``B`` pattern is matched."

msgid "Regular expression that uses this syntax can't be evaluated by index."
msgstr "Regular expression that uses this syntax can't be evaluated by index."

msgid "Group"
msgstr "Group"

msgid "Group syntax is ``(...)``. Group provides the following features:"
msgstr "Group syntax is ``(...)``. Group provides the following features:"

msgid "Back reference"
msgstr "Back reference"

msgid "Scope reducing"
msgstr "Scope reducing"

msgid "You can refer matched groups by ``\\n`` (``n`` is the group number) syntax. For example, ``e(r)\\1o\\1`` matches ``error``. Because ``\\1`` is replaced with match result (``r``) of the first group ``(r)``."
msgstr "You can refer matched groups by ``\\n`` (``n`` is the group number) syntax. For example, ``e(r)\\1o\\1`` matches ``error``. Because ``\\1`` is replaced with match result (``r``) of the first group ``(r)``."

msgid "You can also use more powerful back reference features. See `\"8. Back reference\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L302>`_ for details."
msgstr "You can also use more powerful back reference features. See `\"8. Back reference\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L302>`_ for details."

msgid "Group syntax reduces scope. For example, ``\\[(warning|info)\\]`` reduces choice syntax scope. The regular expression matches ``[warning]`` and ``[info]``."
msgstr "Group syntax reduces scope. For example, ``\\[(warning|info)\\]`` reduces choice syntax scope. The regular expression matches ``[warning]`` and ``[info]``."

msgid "You can also use more powerful group related features. See `\"7. Extended groups\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L225>`_ for details."
msgstr "You can also use more powerful group related features. See `\"7. Extended groups\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L225>`_ for details."

msgid "Character class"
msgstr "Character class"

msgid "Character class syntax is ``[...]``. Character class is useful to specify multiple characters to be matched."
msgstr "Character class syntax is ``[...]``. Character class is useful to specify multiple characters to be matched."

msgid "For example, ``[12]`` matches ``1`` or ``2``."
msgstr "For example, ``[12]`` matches ``1`` or ``2``."

msgid "You can specify characters by range. For example, ``[0-9]`` matches one digit."
msgstr "You can specify characters by range. For example, ``[0-9]`` matches one digit."

msgid "You can also use more powerful character class related features. See `\"6. Character class\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L164>`_ for details."
msgstr "You can also use more powerful character class related features. See `\"6. Character class\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L164>`_ for details."

msgid "Anchor"
msgstr "Anchor"

msgid "There are the following commonly used anchor syntaxes. Some anchors can be evaluated by index."
msgstr "There are the following commonly used anchor syntaxes. Some anchors can be evaluated by index."

msgid "Description"
msgstr "Description"

msgid "Index ready"
msgstr "Index ready"

msgid "The beginning of line"
msgstr "The beginning of line"

msgid "o"
msgstr "o"

msgid "The end of line"
msgstr "The end of line"

msgid "x"
msgstr "x"

msgid "``\\A``"
msgstr "``\\A``"

msgid "The beginning of text"
msgstr "The beginning of text"

msgid "``\\z``"
msgstr "``\\z``"

msgid "The end of text"
msgstr "The end of text"

msgid "Here is an example that uses ``\\z``."
msgstr "Here is an example that uses ``\\z``."

msgid "You can also use more anchors. See `\"5. Anchors\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L152>`_ for details."
msgstr "You can also use more anchors. See `\"5. Anchors\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L152>`_ for details."

msgid "Regular expression that uses this syntax except ``\\A`` and ``\\z`` can't be evaluated by index."
msgstr "Regular expression that uses this syntax except ``\\A`` and ``\\z`` can't be evaluated by index."

msgid "Quantifier"
msgstr "Quantifier"

msgid "There are the following commonly used quantifier syntaxes."
msgstr "There are the following commonly used quantifier syntaxes."

msgid "0 or 1 time"
msgstr "0 or 1 time"

msgid "0 or more times"
msgstr "0 or more times"

msgid "1 or more times"
msgstr "1 or more times"

msgid "For example, ``er+or`` matches ``error``, ``errror`` and so on."
msgstr "For example, ``er+or`` matches ``error``, ``errror`` and so on."

msgid "You can also use more quantifiers. See `\"4. Quantifier\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L119>`_ for details."
msgstr "You can also use more quantifiers. See `\"4. Quantifier\" section in Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE#L119>`_ for details."

msgid "Others"
msgstr "Others"

msgid "There are more syntaxes. If you're interested in them, see `Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE>`_ for details. You may be interested in \"character type\" and \"character\" syntaxes."
msgstr "There are more syntaxes. If you're interested in them, see `Onigmo documentation <https://github.com/k-takata/Onigmo/blob/master/doc/RE>`_ for details. You may be interested in \"character type\" and \"character\" syntaxes."
