1.2.1 - en to ja translation catalogue (86 entries)

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

en: Regular expression
ja: 正規表現

en: Summary
ja: 概要

en: Regular expression support is an experimental feature.
ja: 正規表現は実験的な機能です。

en: 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.
ja: Groongaは正規表現を用いたパターンマッチをサポートしています。正規表現はパターンを表現するために広く使われています。正規表現は複雑なパターンを表現するときに便利です。

en: In most cases, pattern match by regular expression is evaluated as sequential search. It'll be slow for many records and many texts.
ja: 多くの場合は、正規表現検索は逐次検索で実行します。これはたくさんのレコードがあったり、たくさんのテキストがある場合は遅くなります。

en: 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.
ja: いくつかの場合では、正規表現を使ったパターンマッチをインデックスを使って実現します。これは逐次検索よりも非常に高速です。インデックスを使って評価できるパターンについては後述します。

en: 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``.
ja: Groongaは正規表現検索にインデックスを使わないときは、 :ref:`normalizer-auto` ノーマライザーでマッチ対象のテキストを正規化します。これは、 ``Groonga`` というような大文字を使った正規表現は必ずマッチに失敗するということです。なぜなら、 :ref:`normalizer-auto` ノーマライザーはすべてのアルファベットを小文字に正規化するからです。 ``groonga`` は ``Groonga`` にも ``groonga`` にも両方にマッチします。

en: 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.
ja: なぜマッチ対象のテキストを正規化するのでしょうか？それは、インデックスを使って検索できるパターンを増やすためです。もし、Groongaがマッチ対象のテキストを正規化しなかった場合、大文字小文字を区別しないマッチをするために、 ``[Dd][Ii][Ss][Kk]`` や ``(?i)disk`` のような複雑な正規表現を書く必要があります。Groongaは複雑な正規表現に対してインデックスを使うことができません。

en: If you write ``disk`` regular expression for case-insensitive match, Groonga can search the pattern with index. It's fast.
ja: もし、大文字小文字を区別しないマッチに ``disk`` という正規表現を使うなら、Groongaはインデックスを使ってこのパターンを検索できます。これは高速です。

en: 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.
ja: 全文検索では通常、Groongaは検索キーワードを語彙表に指定されているノーマライザーを使って正規化します。正規表現を使った検索では、Groongaは、検索キーワードを正規化しません。これは、正規表現は大文字と小文字に意味があるためです。

en: 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.
ja: したがって、インデックスを使えない正規表現検索では、 :doc:`/reference/commands/normalize` コマンドで検索前に検索キーワードを正規化することをおすすめします。:doc:`/reference/commands/normalize` コマンドを使うことで、検索キーワードをどのように正規化するか考る必要がなくなります。

en: You may feel the behavior is strange. But fast search based on this behavior will help you.
ja: この挙動を奇妙に思うかもしれません。しかし、この挙動のおかげで高速に検索できることはきっとあなたの役に立つはずです。

en: 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.
ja: 正規表現の構文はたくさんあります。GroongaはRubyと同じ構文を使います。なぜなら、Groongaが使っている正規表現エンジンはRubyが使っている正規表現エンジンと同じだからです。この正規表現エンジンは `Onigmo <https://github.com/k-takata/Onigmo/>`_ といいます。他の正規表現の構文との特徴的な違いは ``^`` と ``$`` です。Rubyの正規表現の構文では ``^`` は行頭を表し、 ``$`` は行末を表します。他の多くの正規表現の構文では、 ``^`` はテキストの先頭を表し、 ``$`` はテキストの最後を表します。Rubyの正規表現の構文ではテキストの先頭を表す場合は ``\A`` を使い、テキストの最後を表す場合は ``\z`` を使います。

en: Groonga uses multiline mode since 5.0.6. It means that ``.`` matches on ``\n``.
ja: Groongaは5.0.6からマルチラインモードを有効にしています。これは、 ``.`` が ``\n`` にマッチするということです。

en: But it's meaningless. Because ``\n`` is removed by :ref:`normalizer-auto` normalizer.
ja: しかし、この挙動は意味がありません。なぜなら、 ``\n`` は :ref:`normalizer-auto` ノーマライザーが削除するからです。

en: You can use regular expression in :ref:`select-query` and :ref:`select-filter` options of :doc:`/reference/commands/select` command.
ja: :doc:`/reference/commands/select` コマンドの :ref:`select-query` オプションと :ref:`select-filter` オプションで正規表現を使えます。

en: Usage
ja: 使い方

en: 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.
ja: 以下は使い方を説明するためのスキーマ定義とサンプルデータです。このスキーマにはテーブルは1つだけです。 ``Logs`` というテーブルです。 ``Logs`` テーブルは1つだけカラムを持ちます。 ``message`` というカラムです。ログメッセージは ``message`` カラムに保存されています。

en: Here is an example that uses regular expression in :ref:`select-query`. You need to use ``${COLUMN}:~${REGULAR_EXPRESSION}`` syntax.
ja: :ref:`select-query` で正規表現を使う例です。 ``${COLUMN}:~${REGULAR_EXPRESSION}`` という構文を使います。

en: Here is an example that uses regular expression in :ref:`select-filter`. You need to use ``${COLUMN} @~ ${REGULAR_EXPRESSION}`` syntax.
ja: :ref:`select-filter` で正規表現を使う例です。 ``${COLUMN} @~ ${REGULAR_EXPRESSION}`` という構文を使います。

en: Index
ja: インデックス

en: Groonga can search records by regular expression with index. It's very fast rather than sequential search.
ja: Groongaは正規表現を使った検索をインデックスを使って実現することができます。これは逐次検索より非常に高速です。

en: 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.
ja: しかし、すべての正規表現には対応していません。以下の正規表現にのみ対応しています。対応している正規表現は今後増えていく予定です。

en: Literal only pattern such as ``disk``
ja: ``disk`` のようにリテラルしかないパターン

en: The begging of text and literal only pattern such as ``\Adisk``
ja: ``\A/disk`` のようにテキストの最初でのマッチとリテラルのみのケース

en: The end of text and literal only pattern such as ``disk\z``
ja: ``disk\z`` のようにテキストの最後でのマッチとリテラルのみのケース

en: You need to create an index for fast regular expression search. Here are requirements of index:
ja: 高速に正規表現検索を実現するためにはインデックスを作る必要があります。以下は正規表現用のインデックスが満たさなければいけないことのリストです。

en: Lexicon must be :ref:`table-pat-key` table.
ja: 語彙表は :ref:`table-pat-key` テーブルであること。

en: Lexicon must use :ref:`token-regexp` tokenizer.
ja: 語彙表は :ref:`token-regexp` トークナイザーを使っていること。

en: Index column must has ``WITH_POSITION`` flag.
ja: インデックスカラムは ``WITH_POSITION`` フラグ付きであること。

en: 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.
ja: 語彙表のノーマライザーといった他の設定は用途に応じて適切なものを設定してください。もし、大文字小文字を区別せずに検索したい場合は :ref:`normalizer-auto` ノーマライザーを使ってください。

en: Here are recommended index definitions. In general, it's reasonable index definitions.
ja: 以下はオススメのインデックス定義です。多くの場合はこのインデックス定義が適切です。

en: 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".
ja: これでインデックスを使って正規表現検索をできるようになりました。以下の正規表現は「テキストの先頭」と「リテラル」しか使っていないのでインデックスを使って検索できます。

en: Here is an example that uses :ref:`select-filter` instead of :ref:`select-query`. It uses the same regular expression as the previous example.
ja: 以下は :ref:`select-query` の代わりに :ref:`select-filter` を使った例です。前の例と同じ正規表現を使っています。

en: ``\`` escape will confuse you because there are some steps that require escape between you and Groonga. Here are steps that require ``\`` escape:
ja: ``\`` エスケープは紛らわしいかもしれません。あなたが書いたクエリーをGroongaが実行するまでにエスケープが必要なステップがいくつもあるからです。以下は ``\`` エスケープが必要なステップです。

en: Shell only when you pass Groonga command from command line the following::
ja: シェル。ただし、次のようにGroongaのコマンドをコマンドラインで指定した場合のみ::

en: ``--filter '"message @~ \"\\\\Ahost1:\""'`` is evaluated as the following two arguments by shell:
ja: ``--filter '"message @~ \"\\\\Ahost1:\""'`` はシェルが評価して次の2つの引数になります。

en: 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``).
ja: Groongaコマンドパーサー。ただし、GroongaのコマンドをHTTPパススタイル （ ``/d/COMMAND?ARG1_NAME=ARG1_VALUE&ARG2_NAME=ARG3_VALUE`` ） ではなく、コマンドラインスタイル （ ``COMMAND ARG1_VALUE ARG2_VALUE ...`` ）で指定した場合のみ。

en: ``"message @~ \"\\\\Ahost1:\""`` is evaluated as the following value by Groonga command parser:
ja: ``"message @~ \"\\\\Ahost1:\""`` はGroongaコマンドパーサーが評価して次の値になります。

en: :doc:`/reference/grn_expr` parser. ``\`` escape is required in both :doc:`/reference/grn_expr/query_syntax` and :doc:`/reference/grn_expr/script_syntax`.
ja: :doc:`/reference/grn_expr` パーサー。 :doc:`/reference/grn_expr/query_syntax` でも :doc:`/reference/grn_expr/script_syntax` でも ``\`` エスケープが必要です。

en: ``"\\Ahost1:"`` string literal in script syntax is evaluated as the following value:
ja: スクリプト構文で ``"\\Ahost1:"`` という文字列リテラルを評価すると次の値になります。

en: The value is evaluated as regular expression.
ja: この値が正規表現として評価されます。

en: Syntax
ja: 構文

en: 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.
ja: このセクションでは広く使われている構文だけ説明します。他の構文と詳細は `Onigmoの構文ドキュメント <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja>`_ を参照してください。

en: Escape
ja: エスケープ

en: In regular expression, there are the following special characters:
ja: 正規表現で特別な文字は次の通りです。

en: If you want to write pattern that matches these special character as is, you need to escape them.
ja: これらの特別な文字そのものにマッチするパターンを書きたいときはこれらの文字をエスケープする必要があります。

en: You can escape them by putting ``\`` before special character. Here are regular expressions that match special character itself:
ja: 特別な文字の前に ``\`` を入れることでエスケープできます。以下は特別な文字そのものにマッチする正規表現です。

en: If your regular expression doesn't work as you expected, confirm that some special characters are used without escaping.
ja: 正規表現が期待した通りに動かないときはエスケープ無しで特別な文字が使われていないか確認してください。

en: Choice
ja: 選択

en: Choice syntax is ``A|B``. The regular expression matches when either ``A`` pattern or ``B`` pattern is matched.
ja: 選択の構文は ``A|B`` です。 ``A`` パターンまたは ``B`` パターンにマッチするとこの正規表現にマッチしたことになります。

en: Regular expression that uses this syntax can't be evaluated by index.
ja: この構文を使った正規表現はインデックスを使って評価できません。

en: Group
ja: グループ

en: Group syntax is ``(...)``. Group provides the following features:
ja: グループの構文は ``(...)`` です。グループは次の機能を提供します。

en: Back reference
ja: 後方参照

en: Scope reducing
ja: スケープの限定

en: 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)``.
ja: マッチしたグループを ``\n`` （ ``n`` はグループの番号とする） という構文で参照できます。例えば、 ``e(r)\1o\1`` は ``error`` にマッチします。なぜなら、 ``\1`` は1番目ののグループ ``(r)`` のマッチ結果（ ``r`` ）に置き換えられるからです。

en: 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.
ja: より強力な後方参照機能を使うこともできます。詳細は `Onigmoのドキュメントの「8. 後方参照」セクション <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja#L299>`_ を参照してください。

en: Group syntax reduces scope. For example, ``\[(warning|info)\]`` reduces choice syntax scope. The regular expression matches ``[warning]`` and ``[info]``.
ja: グループ構文はスコープを小さくします。例えば、 ``\[(warning|info)\]`` は選択構文のスコープを小さくしています。この正規表現は ``[warning]`` と ``[info]`` にマッチします。

en: 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.
ja: より強力なグループ関連の機能を使うこともできます。詳細は `Onigmoのドキュメントの「7. 拡張式集合」セクション <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja#L224>`_ を参照してください。

en: Character class
ja: 文字クラス

en: Character class syntax is ``[...]``. Character class is useful to specify multiple characters to be matched.
ja: 文字クラスの構文は ``[...]`` です。文字クラスはマッチする文字を複数指定するときに便利です。

en: For example, ``[12]`` matches ``1`` or ``2``.
ja: たとえば、 ``[12]`` は ``1`` または ``2`` にマッチします。

en: You can specify characters by range. For example, ``[0-9]`` matches one digit.
ja: 範囲で文字を指定することもできます。たとえば、 ``[0-9]`` は1文字の数字にマッチします。

en: 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.
ja: より強力な文字クラス関連の機能も使うことができます。詳細は `Onigmoのドキュメントの「6. 文字集合」セクション <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja#L164>`_ を参照してください。

en: Anchor
ja: アンカー

en: There are the following commonly used anchor syntaxes. Some anchors can be evaluated by index.
ja: 以下はよく使われるアンカーの構文です。いくつかのアンカーはインデックスを使って評価できます。

en: Description
ja: 説明

en: Index ready
ja: インデックスを使えるか

en: The beginning of line
ja: 行頭

en: The end of line
ja: 行末

en: The beginning of text
ja: テキストの先頭

en: The end of text
ja: テキストの末尾

en: Here is an example that uses ``\z``.
ja: 以下は ``\z`` を使った例です。

en: 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.
ja: 他にも使えるアンカーがあります。詳細は `Onigmoのドキュメントの「5. 錨」セクション <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja#L152>`_ を参照してください。

en: Regular expression that uses this syntax except ``\A`` and ``\z`` can't be evaluated by index.
ja: ``\A`` と ``\z`` 以外のアンカーを使った正規表現はインデックスを使って評価できません。

en: Quantifier
ja: 量指定子

en: There are the following commonly used quantifier syntaxes.
ja: 以下はよく使われる量指定子の構文です。

en: 0 or 1 time
ja: 0回か1回

en: 0 or more times
ja: 0回以上

en: 1 or more times
ja: 1回以上

en: For example, ``er+or`` matches ``error``, ``errror`` and so on.
ja: 例えば、 ``er+or`` は ``error`` 、 ``errror`` などにマッチします。

en: 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.
ja: 他の量指定子を使うこともできます。詳細は `Onigmoのドキュメントの「4. 量指定子」セクション <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja#L119>`_ を参照してください。

en: Others
ja: その他

en: 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.
ja: 他にも構文があります。それらに興味がある場合は `Onigmoのドキュメント <https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja>`_ を参照してください。「文字種」や「文字」の構文に興味があるかもしれません。
