Kouhei Sutou
null+****@clear*****
Fri Jun 9 10:40:01 JST 2017
Kouhei Sutou 2017-06-09 10:40:01 +0900 (Fri, 09 Jun 2017) New Revision: 4dfbab9909ea0d92abee2fbb9d705262f27a729b https://github.com/pgroonga/pgroonga.github.io/commit/4dfbab9909ea0d92abee2fbb9d705262f27a729b Message: regular-expression-v2 ja: translate Added files: _po/ja/reference/operators/regular-expression-v2.po ja/reference/operators/regular-expression-v2.md Modified files: _po/ja/reference/index.po ja/reference/index.md Modified: _po/ja/reference/index.po (+2 -2) =================================================================== --- _po/ja/reference/index.po 2017-06-09 00:59:30 +0900 (da07a67) +++ _po/ja/reference/index.po 2017-06-09 10:40:01 +0900 (0b50e0c) @@ -1,7 +1,7 @@ msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" -"PO-Revision-Date: 2017-06-09 00:29+0900\n" +"PO-Revision-Date: 2017-06-09 10:39+0900\n" "Language: ja\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" @@ -115,7 +115,7 @@ msgid " * [`&~` operator][regular-expression-v2]: Search by a regular expressio msgstr " * [`&~`演算子][regular-expression-v2]：正規表現を使った検索" msgid " * [`@~` operator][regular-expression]: Search by a regular expression" -msgstr " * [`&~`演算子][regular-expression-v2]：正規表現を使った検索" +msgstr " * [`@~`演算子][regular-expression]：正規表現を使った検索" msgid "" " * Deprecated since 1.2.1. Use [`&~` operator][regular-expression-v2] inste" Added: _po/ja/reference/operators/regular-expression-v2.po (+299 -0) 100644 =================================================================== --- /dev/null +++ _po/ja/reference/operators/regular-expression-v2.po 2017-06-09 10:40:01 +0900 (8aa070d) @@ -0,0 +1,299 @@ +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\n" +"PO-Revision-Date: 2017-06-09 10:38+0900\n" +"Language: ja\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" + +msgid "" +"---\n" +"title: \"&~ operator\"\n" +"upper_level: ../\n" +"---" +msgstr "" +"---\n" +"title: \"&~演算子\"\n" +"upper_level: ../\n" +"---" + +msgid "# `&~` operator" +msgstr "# `&~`演算子" + +msgid "Since 1.2.1." +msgstr "1.2.1で追加。" + +msgid "## Summary" +msgstr "## 概要" + +msgid "`&~` operator performs regular expression search." +msgstr "`&~`演算子は正規表現検索をします。" + +msgid "PostgreSQL provides the following built-in regular expression operators:" +msgstr "PostgreSQLは次のような組み込みの正規表現演算子を提供しています。" + +msgid " * [`SIMILAR TO`][postgresql-similar-to]" +msgstr "" + +msgid " * [POSIX Regular Expression][postgresql-regexp]" +msgstr " * [POSIX正規表現][postgresql-regexp]" + +msgid "" +"`SIMILAR TO` is based on SQL standard. \"POSIX Regular Expression\" is based on " +"POSIX. They use different regular expression syntax." +msgstr "" +"`SIMILAR TO`はSQL標準をベースにしています。「POSIX正規表現」はPOSIXをベースにしています。これらはそれぞれ違う正規表現の構文を使いま" +"す。" + +msgid "" +"PGroonga's `&~` operator uses another regular expression syntax. `&~` uses syn" +"tax that is used in [Ruby][ruby]. Because PGroonga uses the same regular expre" +"ssion engine that is used in Ruby. It's [Onigmo][onigmo]. See [Onigmo document" +"][onigmo-document] for full syntax definition." +msgstr "" +"PGroongaの`&~`演算子はさらに別の正規表現の構文を使います。`&~`は[Ruby][ruby]で使われている構文を使います。なぜなら、PGroon" +"gaはRubyが使っている正規表現エンジンと同じエンジンを使っているからです。そのエンジンは[Onigmo][onigmo]です。完全な構文定義は[Onig" +"moのドキュメント][onigmo-document]を参照してください。" + +msgid "" +"PGroonga's `&~` operator normalizes target text before matching. It's similar " +"to `~*` operator in \"POSIX Regular Expression\". It performs case insensitive m" +"atch." +msgstr "" +"PGroongaの`&~`演算子はマッチ前に対象文字列を正規化します。これは「POSIX正規表現」の`~*`演算子と似ています。`~*`演算子は大文字小文字" +"の違いを無視してマッチしているかを判断します。" + +msgid "" +"Normalization is different from case insensitive. Normally, normalization is m" +"ore powerful." +msgstr "正規化と大文字小文字の違いを無視することは違います。通常、正規化のほうがよりパワフルです。" + +msgid "" +"Example1: All of \"`A`\", \"`a`\", \"`Ａ`\" (U+FF21 FULLWIDTH LATIN CAPITAL LETTER A)" +", \"`ａ`\" (U+FF41 FULLWIDTH LATIN SMALL LETTER A) are normalized to \"`a`\"." +msgstr "" +"例1：「`A`」も「`a`」も「`Ａ`」（U+FF21 FULLWIDTH LATIN CAPITAL LETTER A）も「`ａ`」（U+FF41 FUL" +"LWIDTH LATIN SMALL LETTER A）もすべて「`a`」に正規化されます。" + +msgid "" +"Example2: Both of full-width Katakana and half-width Katakana are normalized t" +"o full-width Katakana. For example, both of \"`ア`\" (U+30A2 KATAKANA LETTER A) a" +"nd \"`ｱ`\" (U+FF71 HALFWIDTH KATAKANA LETTER A) are normalized to \"`ア`\" (U+30A2 " +"KATAKANA LETTER A)." +msgstr "" +"例2：いわゆる全角カタカナも半角カタカナもどちらも全角カタカナに正規化されます。たとえば、「`ア`」（U+30A2 KATAKANA LETTER A）も「" +"`ｱ`」（U+FF71 HALFWIDTH KATAKANA LETTER A）もどちらも「`ア`」（U+30A2 KATAKANA LETTER A）に正" +"規化されます。" + +msgid "" +"Note that `&~` operator doesn't normalize regular expression pattern. It only " +"normalizes target text. It means that you must use normalized characters in re" +"gular expression pattern." +msgstr "" +"`&~`演算子は正規表現パターンは正規化しないことに注意してください。マッチ対象のテキストだけを正規化します。これは正規表現パターンのなかでは正規化された文" +"字だけを使うべきだということです。" + +msgid "" +"For example, you must not use \"`Groonga`\" as pattern. You must use \"`groonga`\"" +" as pattern. Because \"`G`\" in target text is normalized to \"`g`\". \"`Groonga`\" " +"is never appeared in target text." +msgstr "" +"たとえば、パターンに「`Groonga`」を使ってはいけません。そうではなく、「`groonga`」を使うべきです。なぜなら、対象テキスト中の「`G`」は「" +"`g`」に正規化されるからです。対象テキスト中に「`Groonga`」という文字列は決して現れません。" + +msgid "" +"Some simple regular expression patterns can be searched by index in Groonga. I" +"f index is used, the search is very fast. See [Groonga's regular expression do" +"cument][groonga-regular-expression] for index searchable patterns." +msgstr "" +"いくつかのシンプルな正規表現のパターンはGroonga内でインデックスを使って検索します。インデックスを使った場合は非常に高速です。インデックスを使って検索" +"可能なパターンの詳細は[Groongaの正規表現のドキュメント][groonga-regular-expression]を参照してください。" + +msgid "" +"If a regular expression pattern can't be searchable by index, it's searched by" +" sequential scan in Groonga." +msgstr "もし、正規表現のパターンをインデックスを使って検索できない場合、Groonga内でシーケンシャルスキャンで検索します。" + +msgid "" +"Note that Groonga may search with regular expression pattern by sequential sca" +"n even when `EXPLAIN` reports PostgreSQL uses PGroonga index." +msgstr "" +"`EXPLAIN`でPostgreSQLがPGroongaのインデックスを使っているとレポートするときでも、Groongaは正規表現のパターンを使った検索を" +"シーケンシャルスキャンで実現するかもしれないことに注意してください。" + +msgid "## Syntax" +msgstr "## 構文" + +msgid "" +"```sql\n" +"column &~ regular_expression\n" +"```" +msgstr "" + +msgid "`column` is a column to be searched. It's `text` type or `varchar` type." +msgstr "`column`は検索対象のカラムです。型は`text`型か`varchar`型です。" + +msgid "" +"`regular_expression` is a regular expression to be used as pattern. It's `text" +"` type for `text` type `column`. It's `varchar` type for `varchar` type column" +"." +msgstr "" +"`regular_expression`はパターンとして使う正規表現です。`column`の型が`text`型のときは`text`型です。`column`の" +"型が`varchar`型のときは`varchar`型です。" + +msgid "" +"If `column` value is matched against `regular_expression` pattern, the express" +"ion returns `true`." +msgstr "`column`の値が`regular_expression`パターンにマッチしたら、その式は`true`を返します。" + +msgid "## Operator classes" +msgstr "## 演算子クラス" + +msgid "" +"You need to specify one of the following operator classes to use this operator" +":" +msgstr "この演算子を使うには次のどれかの演算子クラスを指定する必要があります。" + +msgid " * `pgroonga.text_regexp_ops`: For `text`" +msgstr " * `pgroonga.text_regexp_ops`：`text`用" + +msgid " * `pgroonga.varchar_regexp_ops`: For `varchar`" +msgstr " * `pgroonga.varchar_regexp_ops`：`varchar`用" + +msgid " * `pgroonga.text_regexp_ops_v2`: For `text`" +msgstr " * `pgroonga.text_regexp_ops_v2`：`text`用" + +msgid " * `pgroonga.varchar_regexp_ops_v2`: For `varchar`" +msgstr " * `pgroonga.varchar_regexp_ops_v2`：`varchar`用" + +msgid "## Usage" +msgstr "## 使い方" + +msgid "Here are sample schema for examples:" +msgstr "以下は例で使うサンプルスキーマです。" + +msgid "" +"```sql\n" +"CREATE TABLE memos (\n" +" id integer,\n" +" content text\n" +");" +msgstr "" + +msgid "" +"CREATE INDEX pgroonga_content_index ON memos\n" +" USING pgroonga (content pgroonga.text_regexp_ops);\n" +"```" +msgstr "" + +msgid "Here are data for examples:" +msgstr "以下は例で使うデータです。" + +msgid "" +"```sql\n" +"INSERT INTO memos VALUES (1, 'PostgreSQL is a relational database management s" +"ystem.');\n" +"INSERT INTO memos VALUES (2, 'Groonga is a fast full text search engine that s" +"upports all languages.');\n" +"INSERT INTO memos VALUES (3, 'PGroonga is a PostgreSQL extension that uses Gro" +"onga as index.');\n" +"INSERT INTO memos VALUES (4, 'There is groonga command.');\n" +"```" +msgstr "" +"```sql\n" +"INSERT INTO memos VALUES (1, 'PostgreSQLはリレーショナル・データベース管理システムです。');\n" +"INSERT INTO memos VALUES (2, 'Groongaは日本語対応の高速な全文検索エンジンです。');\n" +"INSERT INTO memos VALUES (3, 'PGroongaはインデックスとしてGroongaを使うためのPostgreSQLの拡張機能です" +"。');\n" +"INSERT INTO memos VALUES (4, 'groongaコマンドがあります。');\n" +"```" + +msgid "You can perform regular expression search by `&~` operator:" +msgstr "`&~`演算子を使うと正規表現検索を実行できます。" + +msgid "" +"```sql\n" +"SELECT * FROM memos WHERE content &~ '\\Apostgresql';\n" +"-- id | content \n" +"-- ----+--------------------------------------------------------\n" +"-- 1 | PostgreSQL is a relational database management system.\n" +"-- (1 row)\n" +"```" +msgstr "" +"```sql\n" +"SELECT * FROM memos WHERE content &~ '\\Apostgresql';\n" +"-- id | content \n" +"-- ----+------------------------------------------------------------\n" +"-- 1 | PostgreSQLはリレーショナル・データベース管理システムです。\n" +"-- (1 row)\n" +"```" + +msgid "" +"\"`\\A`\" in \"`\\Apostgresql`\" is a special notation in Ruby regular expression sy" +"ntax. It means that the beginning of text. The pattern means that \"`postgresql" +"`\" must be appeared in the beginning of text." +msgstr "" +"「`\\Apostgresql`」の中の「`\\A`」はRubyの正規表現構文では特別な記法です。これはテキストの最初という意味です。つまり、このパターンは「`" +"postgresql`」がテキストの最初に現れること、という意味です。" + +msgid "" +"Why is \"`PostgreSQL is a ...`\" record matched? Remember that `&~` operator nor" +"malizes target text before matching. It means that \"`PostgreSQL is a ...`\" tex" +"t is normalized to \"`postgresql is a ...`\" text before matching. The normalize" +"d text is started with \"`postgresql`\". So \"`\\Apostgresql`\" regular expression " +"matches to the record." +msgstr "" +"どうして「`PostgreSQLは..`」レコードがマッチしているのでしょうか？`&~`演算子はマッチ前にマッチ対象のテキストを正規化することを思い出してく" +"ださい。つまり、「`PostgreSQLは...`」テキストはマッチ前に「`postgresqlは...`」と正規化されるということです。正規化されたテキス" +"トは「`postgresql`」で始まっています。そのため、「`\\Apostgresql`」正規表現はこのレコードにマッチします。" + +msgid "" +"\"`PGroonga is a PostgreSQL ...`\" record isn't matched. It includes \"`postgresq" +"l`\" in normalized text but \"`postgresql`\" isn't appeared at the beginning of t" +"ext. So it's not matched." +msgstr "" +"\"`PGroongaはPostgreSQLの ...`\"レコードはマッチしません。このレコードは正規化後のテキストに「`postgresql`」を含んでいま" +"すが、「`postgresql`」はテキストの先頭には現れていません。そのためマッチしません。" + +msgid "## See also" +msgstr "## 参考" + +msgid " * [Onigmo's regular expression syntax document][onigmo-document]" +msgstr " * [Onigmoの正規表現構文のドキュメント][onigmo-document]" + +msgid "" +" * [Groonga's regular expression support document][groonga-regular-expression" +"]" +msgstr " * [Groongaの正規表現サポートに関するドキュメント][groonga-regular-expression]" + +msgid "" +"[postgresql-similar-to]:{{ site.postgresql_doc_base_url.en }}/functions-matchi" +"ng.html#FUNCTIONS-SIMILARTO-REGEXP" +msgstr "" +"[postgresql-similar-to]:{{ site.postgresql_doc_base_url.ja }}/functions-matchi" +"ng.html#FUNCTIONS-SIMILARTO-REGEXP" + +msgid "" +"[postgresql-regexp]:{{ site.postgresql_doc_base_url.en }}/functions-matching.h" +"tml#FUNCTIONS-POSIX-REGEXP" +msgstr "" +"[postgresql-regexp]:{{ site.postgresql_doc_base_url.ja }}/functions-matching.h" +"tml#FUNCTIONS-POSIX-REGEXP" + +msgid "[ruby]:https://www.ruby-lang.org/" +msgstr "[ruby]:https://www.ruby-lang.org/ja/" + +msgid "[onigmo]:https://github.com/k-takata/Onigmo" +msgstr "" + +msgid "[onigmo-document]:https://github.com/k-takata/Onigmo/blob/master/doc/RE" +msgstr "[onigmo-document]:https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja" + +msgid "" +"[groonga-regular-expression]:http://groonga.org/docs/reference/regular_express" +"ion.html#regular-expression-index" +msgstr "" +"[groonga-regular-expression]:http://groonga.org/ja/docs/reference/regular_expr" +"ession.html#regular-expression-index" Modified: ja/reference/index.md (+4 -4) =================================================================== --- ja/reference/index.md 2017-06-09 00:59:30 +0900 (bd2a688) +++ ja/reference/index.md 2017-06-09 10:40:01 +0900 (41ecc8a) @@ -56,7 +56,7 @@ PGroongaは`pgroonga`スキーマに関数・演算子・演算子クラスな * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 - * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 + * [`@~`演算子][regular-expression]：正規表現を使った検索 * 1.2.1から非推奨です。代わりに[`&~`演算子][regular-expression-v2]を使ってください。 @@ -106,7 +106,7 @@ PGroongaは`pgroonga`スキーマに関数・演算子・演算子クラスな * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 - * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 + * [`@~`演算子][regular-expression]：正規表現を使った検索 * 1.2.1から非推奨です。代わりに[`&~`演算子][regular-expression-v2]を使ってください。 @@ -218,7 +218,7 @@ PGroonga 1.Y.Zは`pgroonga.XXX_v2`という演算子クラスを提供します * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 - * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 + * [`@~`演算子][regular-expression]：正規表現を使った検索 * 新しく書くコードではこの演算子を使わないでください。後方互換製のために残っているだけの演算子です。 @@ -308,7 +308,7 @@ PGroonga 1.Y.Zは`pgroonga.XXX_v2`という演算子クラスを提供します * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 - * [`&~`演算子][regular-expression-v2]：正規表現を使った検索 + * [`@~`演算子][regular-expression]：正規表現を使った検索 * 新しく書くコードではこの演算子を使わないでください。後方互換製のために残っているだけの演算子です。 Added: ja/reference/operators/regular-expression-v2.md (+121 -0) 100644 =================================================================== --- /dev/null +++ ja/reference/operators/regular-expression-v2.md 2017-06-09 10:40:01 +0900 (1366156) @@ -0,0 +1,121 @@ +--- +title: "&~演算子" +upper_level: ../ +--- + +# `&~`演算子 + +1.2.1で追加。 + +## 概要 + +`&~`演算子は正規表現検索をします。 + +PostgreSQLは次のような組み込みの正規表現演算子を提供しています。 + + * [`SIMILAR TO`][postgresql-similar-to] + + * [POSIX正規表現][postgresql-regexp] + +`SIMILAR TO`はSQL標準をベースにしています。「POSIX正規表現」はPOSIXをベースにしています。これらはそれぞれ違う正規表現の構文を使います。 + +PGroongaの`&~`演算子はさらに別の正規表現の構文を使います。`&~`は[Ruby][ruby]で使われている構文を使います。なぜなら、PGroongaはRubyが使っている正規表現エンジンと同じエンジンを使っているからです。そのエンジンは[Onigmo][onigmo]です。完全な構文定義は[Onigmoのドキュメント][onigmo-document]を参照してください。 + +PGroongaの`&~`演算子はマッチ前に対象文字列を正規化します。これは「POSIX正規表現」の`~*`演算子と似ています。`~*`演算子は大文字小文字の違いを無視してマッチしているかを判断します。 + +正規化と大文字小文字の違いを無視することは違います。通常、正規化のほうがよりパワフルです。 + +例1：「`A`」も「`a`」も「`Ａ`」（U+FF21 FULLWIDTH LATIN CAPITAL LETTER A）も「`ａ`」（U+FF41 FULLWIDTH LATIN SMALL LETTER A）もすべて「`a`」に正規化されます。 + +例2：いわゆる全角カタカナも半角カタカナもどちらも全角カタカナに正規化されます。たとえば、「`ア`」（U+30A2 KATAKANA LETTER A）も「`ｱ`」（U+FF71 HALFWIDTH KATAKANA LETTER A）もどちらも「`ア`」（U+30A2 KATAKANA LETTER A）に正規化されます。 + +`&~`演算子は正規表現パターンは正規化しないことに注意してください。マッチ対象のテキストだけを正規化します。これは正規表現パターンのなかでは正規化された文字だけを使うべきだということです。 + +たとえば、パターンに「`Groonga`」を使ってはいけません。そうではなく、「`groonga`」を使うべきです。なぜなら、対象テキスト中の「`G`」は「`g`」に正規化されるからです。対象テキスト中に「`Groonga`」という文字列は決して現れません。 + +いくつかのシンプルな正規表現のパターンはGroonga内でインデックスを使って検索します。インデックスを使った場合は非常に高速です。インデックスを使って検索可能なパターンの詳細は[Groongaの正規表現のドキュメント][groonga-regular-expression]を参照してください。 + +もし、正規表現のパターンをインデックスを使って検索できない場合、Groonga内でシーケンシャルスキャンで検索します。 + +`EXPLAIN`でPostgreSQLがPGroongaのインデックスを使っているとレポートするときでも、Groongaは正規表現のパターンを使った検索をシーケンシャルスキャンで実現するかもしれないことに注意してください。 + +## 構文 + +```sql +column &~ regular_expression +``` + +`column`は検索対象のカラムです。型は`text`型か`varchar`型です。 + +`regular_expression`はパターンとして使う正規表現です。`column`の型が`text`型のときは`text`型です。`column`の型が`varchar`型のときは`varchar`型です。 + +`column`の値が`regular_expression`パターンにマッチしたら、その式は`true`を返します。 + +## 演算子クラス + +この演算子を使うには次のどれかの演算子クラスを指定する必要があります。 + + * `pgroonga.text_regexp_ops`：`text`用 + + * `pgroonga.varchar_regexp_ops`：`varchar`用 + + * `pgroonga.text_regexp_ops_v2`：`text`用 + + * `pgroonga.varchar_regexp_ops_v2`：`varchar`用 + +## 使い方 + +以下は例で使うサンプルスキーマです。 + +```sql +CREATE TABLE memos ( + id integer, + content text +); + +CREATE INDEX pgroonga_content_index ON memos + USING pgroonga (content pgroonga.text_regexp_ops); +``` + +以下は例で使うデータです。 + +```sql +INSERT INTO memos VALUES (1, 'PostgreSQLはリレーショナル・データベース管理システムです。'); +INSERT INTO memos VALUES (2, 'Groongaは日本語対応の高速な全文検索エンジンです。'); +INSERT INTO memos VALUES (3, 'PGroongaはインデックスとしてGroongaを使うためのPostgreSQLの拡張機能です。'); +INSERT INTO memos VALUES (4, 'groongaコマンドがあります。'); +``` + +`&~`演算子を使うと正規表現検索を実行できます。 + +```sql +SELECT * FROM memos WHERE content &~ '\Apostgresql'; +-- id | content +-- ----+------------------------------------------------------------ +-- 1 | PostgreSQLはリレーショナル・データベース管理システムです。 +-- (1 row) +``` + +「`\Apostgresql`」の中の「`\A`」はRubyの正規表現構文では特別な記法です。これはテキストの最初という意味です。つまり、このパターンは「`postgresql`」がテキストの最初に現れること、という意味です。 + +どうして「`PostgreSQLは..`」レコードがマッチしているのでしょうか？`&~`演算子はマッチ前にマッチ対象のテキストを正規化することを思い出してください。つまり、「`PostgreSQLは...`」テキストはマッチ前に「`postgresqlは...`」と正規化されるということです。正規化されたテキストは「`postgresql`」で始まっています。そのため、「`\Apostgresql`」正規表現はこのレコードにマッチします。 + +"`PGroongaはPostgreSQLの ...`"レコードはマッチしません。このレコードは正規化後のテキストに「`postgresql`」を含んでいますが、「`postgresql`」はテキストの先頭には現れていません。そのためマッチしません。 + +## 参考 + + * [Onigmoの正規表現構文のドキュメント][onigmo-document] + + * [Groongaの正規表現サポートに関するドキュメント][groonga-regular-expression] + +[postgresql-similar-to]:{{ site.postgresql_doc_base_url.ja }}/functions-matching.html#FUNCTIONS-SIMILARTO-REGEXP + +[postgresql-regexp]:{{ site.postgresql_doc_base_url.ja }}/functions-matching.html#FUNCTIONS-POSIX-REGEXP + +[ruby]:https://www.ruby-lang.org/ja/ + +[onigmo]:https://github.com/k-takata/Onigmo + +[onigmo-document]:https://github.com/k-takata/Onigmo/blob/master/doc/RE.ja + +[groonga-regular-expression]:http://groonga.org/ja/docs/reference/regular_expression.html#regular-expression-index -------------- next part -------------- HTML����������������������������...Download