# groonga - オープンソースのカラムストア機能付き全文検索エンジン

- English

# 7.3.54. `select`

## 7.3.54.1. 概要

`select` はテーブルから指定された条件にマッチするレコードを検索し、見つかったレコードを出力します。

`select` は最も重要なgroongaのコマンドです。Groongaの力を最大限に活かすためには `select` を理解する必要があります。

## 7.3.54.2. 構文

このコマンドにはたくさんの引数があります。

必須の引数は `table` だけです。残りは省略できます:

    select table
           [match_columns=null]
           [query=null]
           [filter=null]
           [scorer=null]
           [sortby=null]
           [output_columns="_id, _key, *"]
           [offset=0]
           [limit=10]
           [drilldown=null]
           [drilldown_sortby=null]
           [drilldown_output_columns="_key, _nsubrecs"]
           [drilldown_offset=0]
           [drilldown_limit=10]
           [cache=yes]
           [match_escalation_threshold=0]
           [query_expansion=null]
           [query_flags=ALLOW_PRAGMA|ALLOW_COLUMN]
           [query_expander=null]
           [adjuster=null]
           [drilldown_calc_types=NONE]
           [drilldown_calc_target=null]
           [drilldown_filter=null]
           [sort_keys=null]
           [drilldown_sort_keys=null]

以下の名前付き引数で動的カラム機能を使うことができます。

> - `columns[${NAME}].stage=null`
> - `columns[${NAME}].flags=COLUMN_SCALAR`
> - `columns[${NAME}].type=null`
> - `columns[${NAME}].value=null`
> - `columns[${NAME}].window.sort_keys=null`
> - `columns[${NAME}].window.group_keys=null`

`${NAME}` には1つ以上のアルファベット、数字、 `_` を使うことができます。たとえば、 `column1` は有効な `${NAME}` です。これは通常のカラムと同じルールです。 name も見てください。

同じ `${NAME}` も持つ引数は同じグループになります。

たとえば、以下の引数は1つの動的カラムを指定しています。

> - `--columns[name].stage initial`
> - `--columns[name].type UInt32`
> - `--columns[name].value 29`

以下の引数は2つの動的カラムを指定しています。

> - `--columns[name1].stage initial`
> - `--columns[name1].type UInt32`
> - `--columns[name1].value 29`
> - `--columns[name2].stage filtered`
> - `--columns[name2].type Float`
> - `--columns[name2].value '_score * 0.1'`

このコマンドには高度なドリルダウン機能のために以下の名前付き引数があります。

> - `drilldowns[${LABEL}].keys=null`
> - `drilldowns[${LABEL}].sort_keys=null`
> - `drilldowns[${LABEL}].output_columns="_key, _nsubrecs"`
> - `drilldowns[${LABEL}].offset=0`
> - `drilldowns[${LABEL}].limit=10`
> - `drilldowns[${LABEL}].calc_types=NONE`
> - `drilldowns[${LABEL}].calc_target=null`
> - `drilldowns[${LABEL}].filter=null`
> - `drilldowns[${LABEL}].columns[${NAME}].stage=null`
> - `drilldowns[${LABEL}].columns[${NAME}].flags=COLUMN_SCALAR`
> - `drilldowns[${LABEL}].columns[${NAME}].type=null`
> - `drilldowns[${LABEL}].columns[${NAME}].value=null`
> - `drilldowns[${LABEL}].columns[${NAME}].window.sort_keys=null`
> - `drilldowns[${LABEL}].columns[${NAME}].window.group_keys=null`

バージョン 6.0.3 で撤廃: `drilldown[...]` 構文は非推奨になりました。代わりに `drilldowns[...]` を使用してください。

`${LABEL}` には1つ以上のアルファベット、数字、 `_` 、 `.` を使うことができます。たとえば、 `parent.sub1` は有効な `${LABEL}` です。

同じ `${LABEL}` も持つ引数は同じグループになります。

たとえば、以下の引数は1つのドリルダウンを指定しています。

> - `--drilldowns[label].keys column`
> - `--drilldowns[label].sort_keys -_nsubrecs`

以下の引数は2つのドリルダウンを指定しています。

> - `--drilldowns[label1].keys column1`
> - `--drilldowns[label1].sort_keys -_nsubrecs`
> - `--drilldowns[label2].keys column2`
> - `--drilldowns[label2].sort_keys _key`

## 7.3.54.3. 使い方

例を使いながら `select` の使い方を学びましょう。このセクションではよく使われる使い方を紹介します。

使い方を示すために使うスキーマ定義とサンプルデータは以下の通りです。

実行例:

    table_create Entries TABLE_HASH_KEY ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Entries content COLUMN_SCALAR Text
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Entries n_likes COLUMN_SCALAR UInt32
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Entries tag COLUMN_SCALAR ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    table_create Terms TABLE_PAT_KEY ShortText --default_tokenizer TokenBigram --normalizer NormalizerAuto
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Terms entries_key_index COLUMN_INDEX|WITH_POSITION Entries _key
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Terms entries_content_index COLUMN_INDEX|WITH_POSITION Entries content
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table Entries
    [
    {"_key":    "The first post!",
     "content": "Welcome! This is my first post!",
     "n_likes": 5,
     "tag": "Hello"},
    {"_key":    "Groonga",
     "content": "I started to use Groonga. It's very fast!",
     "n_likes": 10,
     "tag": "Groonga"},
    {"_key":    "Mroonga",
     "content": "I also started to use Mroonga. It's also very fast! Really fast!",
     "n_likes": 15,
     "tag": "Groonga"},
    {"_key":    "Good-bye Senna",
     "content": "I migrated all Senna system!",
     "n_likes": 3,
     "tag": "Senna"},
    {"_key":    "Good-bye Tritonn",
     "content": "I also migrated all Tritonn system!",
     "n_likes": 3,
     "tag": "Senna"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 5]

ブログエントリ用の `Entries` テーブルがあります。各エントリはタイトルと内容と「いいね！」数、タグを持っています。タイトルは `Entries` のキーとします。内容は `Entries.content` カラムの値とします。「いいね！」数は `Entries.n_likes` カラムの値とします。タグは `Entries.tag` カラムの値とします。

`Entries._key` カラムと `Entries.content` カラムには `TokenBigram` トークナイザーを使ったインデックスを作成します。そのため、 `Entries._key` と `Entries.content` は両方とも全文検索できます。

これで例を示すためのスキーマとデータの準備ができました。

### 7.3.54.3.1. 簡単な使い方

上記のスキーマとデータを使った一番簡単な使い方は以下の通りです。これは `Entries` テーブルのすべてのレコードを出力します。

実行例:

    select Entries
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

どうしてこのコマンドがすべてのレコードを出力するのでしょうか？理由は2つです。1つ目の理由はこのコマンドが検索条件を何も指定していないからです。検索条件を指定しないとすべてのレコードがマッチします。2つ目の理由は全レコード数が5だからです。 `select` コマンドはデフォルトでは最大10レコードを出力します。この例では5レコードしかありません。これは10よりも少ないのですべてのレコードを出力します。

### 7.3.54.3.2. 検索条件

検索条件は `query` または `filter` で指定します。 `query` と `filter` を両方指定することもできます。この場合は `query` と `filter` の両方の条件にマッチしたレコードが出力されます。

#### 7.3.54.3.2.1. 検索条件: `query`

`query` はWebページの検索ボックス用に用意されています。例えば、google.co.jpにあるような検索ボックスです。 `query` の検索条件はスペース区切りでキーワードを指定します。例えば、 `検索 エンジン` は `検索` と `エンジン` という2つのキーワードを含むレコードを検索します。

通常は `query` 引数は全文検索条件を指定するために使います。全文検索条件以外も指定できますが、その用途には `filter` 引数の方が向いています。

`query` 引数で全文検索条件を指定する場合は、 `match_columns` 引数と一緒に使います。 `match_columns` はどのカラムまたはインデックスを使って `query` を検索するかを指定します。

以下は簡単な `query` の使用例です。

実行例:

    select Entries --match_columns content --query fast
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `fast` を含んでいるレコードを検索します。

`query` はクエリー構文という構文を使いますが、詳細はここでは説明しません。詳細は クエリー構文 を参照してください。

#### 7.3.54.3.2.2. 検索条件: `filter`

`filter` は複雑な検索条件を指定するために用意されています。ECMAScriptのような構文で `filter` に検索条件を指定します。

以下は簡単な `filter` の使用例です。

実行例:

    select Entries --filter 'content @ "fast" && _key == "Groonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中の `content` カラムの値に `fast` という単語を含んでいて、かつ、 `_key` が `Groonga` のレコードを検索します。このコマンドの中には `@` と `&&` と `==` という3つの演算子があります。 `@` は全文検索用の演算子です。 `&&` と `==` はECMAScriptと同じ意味です。 `&&` が論理積用の演算子で `==` が等価演算子です。

`filter` にはもっと演算子や構文があります。例えば、 `(...)` を使った検索条件のグループ化などです。しかし、ここでは詳細は説明しません。詳細は スクリプト構文 を参照してください。

### 7.3.54.3.3. ページング

`offset` と `limit` を指定することで出力されるレコードの範囲を指定できます。以下は2番目のレコードだけを出力する例です。

実行例:

    select Entries --offset 1 --limit 1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

`offset` は0始まりです。 `--offset 1` は2番目以降のレコードを出力するという意味になります。

`limit` は出力レコード数の最大値を指定します。 `--limit 1` は多くても1レコードを出力するという意味になります。もし、1つもレコードがマッチしていなければ `select` コマンドはどのレコードも出力しません。

### 7.3.54.3.4. 全レコード数

`--limit 0` を使うとレコードの内容は取得せずに全レコード数だけを取得できます。

実行例:

    select Entries --limit 0
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ]
    #     ]
    #   ]
    # ]

`--limit 0` はマッチしたレコード数だけを取得したいときにも便利です。

### 7.3.54.3.5. ドリルダウン

1回の `select` で検索結果だけでなく、検索結果をグループ化した結果も一緒に取得できます。SQLでは2回以上 `SELECT` を使わなければいけない場合でも、Groongaの場合は1回の `select` で実現できます。

Groongaではこの機能を ドリルダウン と呼んでいます。他の検索エンジンでは ファセット検索 とも呼ばれています。

例えば、以下の状況を考えてみましょう。

`fast` という単語を含むエントリーを探します。

実行例:

    select Entries --filter 'content @ "fast"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

`--filter 'content @ "fast" && tag == "???"` というように、追加の検索条件として `tag` を使いたいとします。しかし、 `content @ "fast"` の結果を見るまでは適切なタグはわかりません。

もし、有効なタグそれぞれについてマッチするレコード数がわかれば、その中から適切なタグを選ぶことができます。このような用途のためにドリルダウンを使えます。

実行例:

    select Entries --filter 'content @ "fast"' --drilldown tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ],
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

`--drilldown tag` は「有効なタグ」と「そのタグを持っているレコード数」のペアをリストにして返します。このリストからタグを選ぶと「検索したけどヒット数0」という状況を避けることができます。また、リストの中からレコード数が少ないタグを選べば「検索結果が多すぎる」という状況も避けることができます。

ドリルダウン結果を使うと次のようなUIを作ることができます。

> - 検索結果を絞り込むリンク。（ユーザーはキーボードから検索クエリーを入力する必要がなくなります。単にリンクをクリックすればよいからです。)

多くのECサイトではこのUIを使っています。Amazonのサイドメニューを見てください。

Groongaはグループ化したレコードの数を数えるだけでなく、グループ化したレコードのカラムの値の中から最大値・最小値を見つけたり、合計値を計算したりすることができます。詳細は ドリルダウン関連の引数 を参照してください。

### 7.3.54.3.6. 動的カラム

1回の `select` 実行中に0個以上のカラムを動的に作ることができます。この機能を使うと計算した値に対してドリルダウンしたりウィンドウ関数と使ったりできます。

以下は計算した値に対してドリルダウンするために動的カラムを使う例です。この例では `n_likes_class` という名前のカラムを新しく作っています。 `n_likes_class` カラムには `Entry.n_likes` の値を分類した値を入れます。この例では `Entry.n_likes` カラムの値を `10` 刻みで分類し、一番小さい数値をその分類の代表値とします。もし、 `Entry.n_likes` の値が `3` や `5` のように `0` から `9` の間の値なら、 `n_likes_class` の値（分類した値）は `0` になります。もし、 `Entry.n_likes` の値が `10` や `15` のように `10` から `19` の間の値なら、 `n_likes_class` の値（分類した値）は `10` になります。

このような分類をするために number_classify 関数を使えます。 number_classify 関数を使うためには plugin_register コマンドで `functions/number` プラグインを登録する必要があります。

この例では `n_likes_class` の値でドリルダウンしています。このドリルダウン結果があるとデータの傾向がわかりやすくなるでしょう。

実行例:

    plugin_register functions/number
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    select \
      --table Entries \
      --columns[n_likes_class].stage initial \
      --columns[n_likes_class].type UInt32 \
      --columns[n_likes_class].value 'number_classify(n_likes, 10)' \
      --drilldown n_likes_class \
      --drilldown_sort_keys _nsubrecs \
      --output_columns n_likes,n_likes_class
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes_class",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         5,
    #         0
    #       ],
    #       [
    #         10,
    #         10
    #       ],
    #       [
    #         15,
    #         10
    #       ],
    #       [
    #         3,
    #         0
    #       ],
    #       [
    #         3,
    #         0
    #       ]
    #     ],
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "UInt32"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         10,
    #         2
    #       ],
    #       [
    #         0,
    #         3
    #       ]
    #     ]
    #   ]
    # ]

詳細は 動的カラム関連の引数 を見てください。

### 7.3.54.3.7. ウィンドウ関数

グループ化したレコードの値を使って各レコードの値を計算することができます。たとえば、グループ毎に合計を計算して、合計値をすべてのレコードに格納できます。ドリルダウンもグループ毎に合計を計算できますが、すべてのレコードに合計を格納するのではなく、各グループ合計を格納する点が違います。

以下はウィンドウ関数を使った結果の例です。すべてのレコードが合計値を持っています。

グループ番号 | 合計対象の値 | 合計結果
--- | --- | ---
1 | 5 | 5
2 | 10 | 25
2 | 15 | 25
3 | 3 | 8
3 | 5 | 8

以下はドリルダウンを使った結果の例です。各グループが合計値を持っています。

グループ番号 | 合計対象の値 | 合計結果
--- | --- | ---
1 | 5 | 5
2 | 10, 15 | 25
3 | 3, 5 | 8

ウィンドウ関数はデータ解析に有用です。

以下は `Entries.tag` 毎に `Entries.n_likes` の合計を計算する例です。

実行例:

    plugin_register functions/number
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    select \
      --table Entries \
      --columns[n_likes_sum_per_tag].stage initial \
      --columns[n_likes_sum_per_tag].type UInt32 \
      --columns[n_likes_sum_per_tag].value 'window_sum(n_likes)' \
      --columns[n_likes_sum_per_tag].window.group_keys tag \
      --output_columns tag,n_likes,n_likes_sum_per_tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "tag",
    #           "ShortText"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes_sum_per_tag",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5,
    #         5
    #       ],
    #       [
    #         "Groonga",
    #         10,
    #         25
    #       ],
    #       [
    #         "Groonga",
    #         15,
    #         25
    #       ],
    #       [
    #         "Senna",
    #         3,
    #         6
    #       ],
    #       [
    #         "Senna",
    #         3,
    #         6
    #       ]
    #     ]
    #   ]
    # ]

詳細は ウィンドウ関数関連の引数 を見てください。

## 7.3.54.4. 引数

このセクションではすべての引数について説明します。引数はカテゴリわけしています。

### 7.3.54.4.1. 必須引数

`table` だけが必須の引数です。

#### 7.3.54.4.1.1. `table`

検索対象のテーブルを指定します。 `table` は必ず指定しなければいけません。

存在しないテーブルを指定するとエラーが返ります。

実行例:

    select Nonexistent
    # [
    #   [
    #     -22,
    #     1337566253.89858,
    #     0.000355720520019531,
    #     "[select][table] invalid name: <Nonexistent>",
    #     [
    #       [
    #         "grn_select",
    #         "proc_select.c",
    #         3006
    #       ]
    #     ]
    #   ]
    # ]

### 7.3.54.4.2. 検索関係の引数

検索関係の引数がいくつかあります。一般的には、検索ボックスを実装するために `match_columns` と `query` 引数を使い、複雑な検索機能を実装するために `filter` 引数を使います。

`query` と `filter` を指定した場合は、 `query` と `filter` にマッチしたレコードが選択されます。 `query` と `filter` のどちらも指定しなかった場合はすべてのレコードが選択されます。

#### 7.3.54.4.2.1. `match_columns`

`query` 引数の値で全文検索をするときに使うデフォルトの検索対象カラムを指定します。全文検索対象のカラムは `query` 引数でも指定できます。検索対象カラムを `match_columns` で指定する場合と `query` で指定する場合の違いは重みとスコアー関数を指定できるかどうかです。 `match_columns` では指定できますが、 `query` では指定できません。

重みは検索対象カラムの相対的な重要度です。重みの大きい検索対象カラムでマッチした場合は小さい検索対象カラムでマッチした場合よりも多くのヒットスコアがつきます。デフォルトの重みは1です。

以下は簡単な `match_columns` の使用例です。

実行例:

    select Entries --match_columns content --query fast --output_columns '_key, _score'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         1
    #       ],
    #       [
    #         "Mroonga",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

`--match_columns content` はデフォルトの全文検索対象カラムに `content` カラムを使用し、その重みは1、という意味になります。 `--output_columns '_key, _score'` はこの `select` コマンドがマッチしたレコードの `_key` の値と `_score` の値を出力する、ということを指定しています。

`_score` の値に注目してください。 `_score` の値は `query` 引数の値に何個マッチしたかになっています。この例では、 `query` 引数の値は `fast` です。 `_score` の値が1ということは `content` カラムの中に `fast` が1つだけあるということです。 `_score` の値が2ということは `content` カラムの中に `fast` が2つあるということです。

重みを指定するためには `column * weight` という構文を使います。以下は重みの使用例です。

実行例:

    select Entries --match_columns 'content * 2' --query fast --output_columns '_key, _score'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Mroonga",
    #         4
    #       ]
    #     ]
    #   ]
    # ]

`--match_columns 'content * 2'` はデフォルトの全文検索用カラムとして `content` カラムを使い、その重みは2という意味です。

`_score` の値に注目してください。 `_score` の値が2倍になっています。これは重みを2にしたからです。

デフォルトの全文検索対象カラムとして複数のカラムを指定することができます。複数のカラムを指定した場合はすべてのカラムに対して全文検索が行われ、ヒットスコアが積算されます。つまり、 `query` 引数の値がどれか1つでも全文検索対象カラムにマッチしたら、そのレコードはマッチしたものとして扱われます。

複数のカラムを指定するには `column1 * weight1 || column2 * weight2 || ...` という構文を使います。 `* weight` は省略することができます。省略した場合は重みが1になります。以下は複数カラムの使用例です。

実行例:

    select Entries --match_columns '_key * 10 || content' --query groonga --output_columns '_key, _score'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         11
    #       ]
    #     ]
    #   ]
    # ]

`--match_columns '_key * 10 || content'` はデフォルト検索対象カラムが `_key` カラムと `content` カラムで、 `_key` カラムの重みは10、 `content` カラムの重みは1という意味です。この重み付けは `_key` カラムの値は `content` カラムの値よりも重要だという意味になります。この例では、ブログエントリのタイトルはブログエントリの内容よりも重要だということです。

スコアー関数を指定することもできます。詳細は スコアラー を参照してください。

スコアー関数と scorer パラメーターは関係ないので注意してください。

`--match_columns` にはインデックスカラムを指定することもできます。その場合、どのインデックスが使われ、どのデータカラムを検索するのかを明示的に制御することができます。

もし、データカラムが `--match_columns` へと指定されていたら、Groongaは自動的に関連するインデックスカラムを探します。しかし、どのインデックスカラムが実際に選択されるかは仕様として定義されていません。つまり、もし複数のインデックスカラムが1つのデータカラムに対して作成された場合、事前にどのインデックスカラムが選択されるかはわからないということです。(多くの場合は最後に作成されたインデックスカラムが選択されますが、これはドキュメント化されていない振る舞いです。)

以下はインデックスカラムをどのように指定するかの例です。

- 1つのデータカラム用のインデックスカラム

- 複数のデータカラム用のインデックスカラム

1つのデータカラム用のインデックスカラムを使う場合、データカラムに対応したインデックスカラムを指定します。つまり、 `TERMS_TABLE.INDEX_COLUMN` を指定するということです。一方で複数のデータカラムに対するインデックスカラムを使う場合、デフォルトではすべてのデータカラムが検索されます。もし特定のインデックスを使い、特定のデータカラムのみを検索したいなら、インデックスカラム名にデータカラム名を付与します。例えば、 `TERMS_TABLE.INDEX_COLUMN.DATA_COLUMN` といった具合にです。詳しい例は インデックス名を指定した全文検索 を参照してください。

#### 7.3.54.4.2.2. `query`

クエリーテキストを指定します。通常、全文検索をするために `match_columns` 引数と一緒に使います。 `query` 引数はWebページにある全文検索フォームで使いやすいように設計されています。クエリーテキストは クエリー構文 という書式を使います。この書式はGoogleの検索フォームのように一般的な検索フォームと似ています。例えば、 `word1 word2` は `word1` と `word2` を含んでいるレコードを検索するという意味になります。 `word1 OR word2` は `word1` または `word2` を含んでいるレコードを検索するという意味になります。

以下は論理積を使った検索の簡単な例です。

実行例:

    select Entries --match_columns content --query "fast groonga"
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `fast` と `groonga` の2つの単語を含んでいるレコードを検索します。

以下は論理和を使った検索の簡単な例です。

実行例:

    select Entries --match_columns content --query "groonga OR mroonga"
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `fast` または `groonga` のどちらかの単語を含んでいるレコードを検索します。

他の構文は クエリー構文 を参照してください。

`query` では全文検索だけではなく他の条件も使えます。例えば、 `column:value` は `column` の値が `value` と等しいという意味です。 `column:<value` は `column` の値が `value` より小さいという意味です。

以下は等価演算子を使った検索の簡単な例です。

実行例:

    select Entries --query _key:Groonga
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `_key` カラムの値が `Groonga` であるレコードを検索します。

以下は比較演算子を使った検索の簡単な例です。

実行例:

    select Entries --query n_likes:<11
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `n_likes` カラムの値が `11` より小さいレコードを検索します。

他の演算子は クエリー構文 を参照してください。

#### 7.3.54.4.2.3. `filter`

フィルターテキストを指定します。通常、 `filter` は複雑な条件を指定するために使います。 `filter` は `query` 引数と一緒に使うこともできます。 `filter` と `query` を両方指定した場合はそれらを論理積で組み合わせます。つまり、マッチするレコードは `filter` にも `query` にもマッチしなければいけないということです。

`filter` 引数は複雑な条件用に設計されています。フィルターテキストは スクリプト構文 書式で指定します。この書式はECMAScriptに似ています。例えば、 `column == "value"` は `column` カラムの値が `"value"` と等しいという意味です。 `column < value` は `column` カラムの値が `value` よりも小さいという意味です。

以下は等価演算子を使った検索の簡単な例です。

実行例:

    select Entries --filter '_key == "Groonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `_key` カラムの値が `Groonga` であるレコードを検索します。

以下は比較演算子を使った検索の簡単な例です。

実行例:

    select Entries --filter 'n_likes < 11'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `n_likes` カラムの値が `11` より小さいレコードを検索します。

他の演算子は スクリプト構文 を参照してください。

### 7.3.54.4.3. 高度な検索のための引数

#### 7.3.54.4.3.1. `match_escalation_threshold`

検索方法をエスカレーションするかどうかを決定するための閾値を指定します。この閾値はマッチしたレコード数との比較に使われます。マッチしたレコード数がこの閾値以下の場合は検索方法をエスカレーションします。検索方法のエスカレーションについては 検索 を参照してください。

デフォルトの閾値は0です。これは1つもレコードがマッチしなかったときだけ検索方法をエスカレーションするということです。

デフォルトの閾値は以下の方法でカスタマイズできます。

> - configureの `--with-match-escalation-threshold` オプション

> - groongaコマンドの `--match-escalation-threshold` オプション

> - 設定ファイルの `match-escalation-threshold` 設定項目

以下は簡単な `match_escalation_threshold` の使用例です。最初の `select` は `match_escalation_threshold` 引数がありません。2番目の `select` は `match_escalation_threshold` 引数があります。

実行例:

    select Entries --match_columns content --query groo
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]
    select Entries --match_columns content --query groo --match_escalation_threshold -1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         0
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ]
    #     ]
    #   ]
    # ]

最初の `select` コマンドは `Entries` テーブルから `content` カラムの値に `groo` という単語を含むレコードを検索します。しかし、この検索ではどのレコードにもマッチしません。これは、 `TokenBigram` トークナイザーは `groonga` を `gr|ro|oo|on|ng|ga` ではなく `groonga` にトークナイズするからです。（ `TokenBigramSplitSymbolAlpha` は `groonga` を `gr|ro|oo|on|ng|ga` にトークナイズします。詳細は トークナイザー を見てください。）つまり、 `groonga` はインデックスに登録されていますが、 `groo` はインデックスに登録されていないということです。インデックスに登録されていないので完全一致検索では `groo` はどのレコードにもマッチしません。このケースでは検索方法のエスカレーションが行われています。なぜならばマッチしたレコード数（0）が `match_escalation_threshold` （0）の値と等しいからです。非分かち書き検索では `groo` で1つのレコードがマッチします。

2番目の `select` コマンドも `Entries` テーブルから `content` カラムの値に `groo` という単語を含むレコードを検索します。そして、この `select` コマンドもマッチしません。この場合、マッチしたレコード数（0）が `match_escalation_threshold` （-1）より大きいので、検索方法をエスカレーションしません。そして、1つもレコードがマッチしません。

#### 7.3.54.4.3.2. `query_expansion`

バージョン 3.0.2 で撤廃: 代わりに query_expander を使ってください。

#### 7.3.54.4.3.3. `query_flags`

`query` パラメーターの構文をカスタマイズします。デフォルトでは `query` パラメーターでカラムの値を更新することはできません。しかし、 `query_flags` に `ALLOW_COLUMN|ALLOW_UPDATE` を指定することで `query` でカラムの値を更新することができます。

指定可能な値は以下の通りです。

- `ALLOW_PRAGMA`
- `ALLOW_COLUMN`
- `ALLOW_UPDATE`
- `ALLOW_LEADING_NOT`
- `NONE`

`ALLOW_PRAGMA` を指定すると `query` の先頭でプラグマを指定することができます。この機能はまだ実装されていません。

`ALLOW_COLUMN` を指定すると `match_columns` で指定していないカラムでも検索できるように成ります。カラムを指定するには `COLUMN:...` というような構文を使います。

`ALLOW_UPDATE` を指定すると `COLUMN:=NEW_VALUE` という構文を使って `query` でカラムの値を更新できます。カラム更新用の構文ではカラムを指定する必要があるため、 `ALLOW_COLUMN` も一緒に指定する必要があります。

`ALLOW_LEADING_NOT` を指定すると `-WORD` という構文を使って最初の条件として否定条件を指定できます。このクエリーは `WORD` にマッチしないレコードを検索します。最初の条件に否定条件を使ったクエリーは多くの場合重いクエリーになります。これは多くのレコードにマッチするからです。そのため、このフラグはデフォルトでは無効になっています。もし、このフラグを使う場合は重いクエリーとなるということを十分気をつけてください。

`NONE` は単に無視されます。フラグを指定しないときに `NONE` を使えます。

これらのフラグは `ALLOW_COLUMN|ALLOW_UPDATE` のように `|` で区切って同時に指定することができます。

デフォルト値は `ALLOW_PRAGMA|ALLOW_COLUMN` です。

以下は `ALLOW_COLUMN` の使用例です。

実行例:

    select Entries --query content:@mroonga --query_flags ALLOW_COLUMN
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `mroonga` を含んでいるレコードを検索します。

以下は `ALLOW_UPDATE` の使用例です。

実行例:

    table_create Users TABLE_HASH_KEY ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Users age COLUMN_SCALAR UInt32
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table Users
    [
    {"_key": "alice", "age": 18},
    {"_key": "bob",   "age": 20}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 2]
    select Users --query age:=19 --query_flags ALLOW_COLUMN|ALLOW_UPDATE
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "age",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         "alice",
    #         19
    #       ],
    #       [
    #         2,
    #         "bob",
    #         19
    #       ]
    #     ]
    #   ]
    # ]
    select Users
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "age",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         "alice",
    #         19
    #       ],
    #       [
    #         2,
    #         "bob",
    #         19
    #       ]
    #     ]
    #   ]
    # ]

最初の `select` コマンドは全てのレコードの `age` カラムの値を `19` にします。二番目の `select` コマンドは `age` カラムの値を出力します。

以下は `ALLOW_LEADING_NOT` の使用例です。

実行例:

    select Entries --match_columns content --query -mroonga --query_flags ALLOW_LEADING_NOT
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `mroonga` を含んでいないレコードを検索します。

以下は `NONE` の使用例です。

実行例:

    select Entries --match_columns content --query 'mroonga OR _key:Groonga' --query_flags NONE
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `Entries` テーブルの中から `content` カラムの値に `mroonga` または `_key:Groonga` のどちらかの単語を含んでいるレコードを検索します。 `_key:Groonga` が `_key` カラムの値が `Groonga` という条件にはならないことに注意してください。これは `ALLOW_COLUMN` フラグが指定されていないからです。

クエリー構文 も見てください。

#### 7.3.54.4.3.4. `query_expander`

クエリー展開用の引数です。クエリー展開はクエリー中の特定の単語を別の単語に置換します。通常は類義語検索に使います。

`query` 引数の値を置換するために使うカラムを指定します。この引数の値の書式は「 `${TABLE}.${COLUMN}` 」です。例えば、 「 `Terms.synonym` 」は `Terms` テーブルの `synonym` カラムを指定しています。

クエリー展開用のテーブルを「置換テーブル」と呼びます。置換テーブルのキーは `ShortText` にしてください。そのため、配列テーブル（ `TABLE_NO_KEY` ）は置換テーブルに使うことはできません。なぜなら、配列テーブルにはキーがないからです。

クエリー展開用のカラムを「置換カラム」と呼びます。置換カラムの値の型は `ShortText` にしてください。カラムの種類はベクター（ `COLUMN_VECTOR` ）にしてください。

クエリー展開はクエリーの中にある置換テーブルのキーを置換カラムの値で置換します。 `query` の中にある単語が置換テーブルのキーだったら、キーに対応する置換カラムの値でその単語を置換します。置換は再帰的に実行しません。これは、置換されたクエリー内に置換対象の単語があっても置換されないということです。

以下は `query_expander` の簡単な使用例を示すためのサンプル置換テーブルです。

実行例:

    table_create Thesaurus TABLE_PAT_KEY ShortText --normalizer NormalizerAuto
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Thesaurus synonym COLUMN_VECTOR ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table Thesaurus
    [
    {"_key": "mroonga", "synonym": ["mroonga", "tritonn", "groonga mysql"]},
    {"_key": "groonga", "synonym": ["groonga", "senna"]}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 2]

`Thesaurus` 置換テーブルは2つの類義語があります。 `"mroonga"` と `"groonga"` です。ユーザが `"mroonga"` で検索すると、Groongaは `"((mroonga) OR (tritonn) OR (groonga mysql))"` で検索します。ユーザーが `"groonga"` で検索すると、Groongaは `"((groonga) OR (senna))"` で検索します。

通常、置換テーブルにはノーマライザーを指定したほうがよいです。たとえば、ノーマライザーを指定すると、置換対象の単語に対して大文字小文字区別せずにマッチするようになります。利用可能なノーマライザーは ノーマライザー を参照してください。

これらの類義語の値の中に `"mroonga"` や `"groonga"` といったキーの値も含まれていることに注意してください。このように類義語にキーの値も含めることを推奨します。もしキーの値を含めないと、置換した値には元の置換対象の値が含まれません。通常、元の値が含まれていた方がよい検索結果になります。もし、検索してほしくない単語がある場合は、元の単語を含めないでください。例えば、空のベクター値を指定することで「ストップワード」機能を実現することもできます。

以下は簡単な `query_expander` の使用例です。

実行例:

    select Entries --match_columns content --query "mroonga"
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]
    select Entries --match_columns content --query "mroonga" --query_expander Thesaurus.synonym
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]
    select Entries --match_columns content --query "((mroonga) OR (tritonn) OR (groonga mysql))"
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

最初の `select` コマンドはクエリー展開を使いません。そのため、 `"tritonn"` という単語を含んでいるレコードは見つかりません。2番目の `select` コマンドはクエリー展開を使っています。そのため、 `"tritonn"` という単語を含んでいるレコードが見つかります。3番目の `select` コマンドはクエリー展開を使っていませんが、2番目の `select` コマンドと同じ結果になります。これは、3番目の `select` コマンドは展開後のクエリーを使っているからです。

それぞれの置換する値は `(...)` や `OR` といった クエリー構文 を使えます。これらの構文を使うことにより複雑な置換をすることができます。

以下はクエリー構文を使った複雑な置換の使用例です。

実行例:

    load --table Thesaurus
    [
    {"_key": "popular", "synonym": ["popular", "n_likes:>=10"]}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 1]
    select Entries --match_columns content --query "popular" --query_expander Thesaurus.synonym
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `load` コマンドは新しく `"popular"` という類義語を登録しています。これは `((popular) OR (n_likes:>=10))` に置換されます。置換されたクエリーは、「popular」というのは「popular」という単語を含んでいるか10以上の「いいね！」数を持つエントリという意味になります。

この `select` コマンドは `Entries` テーブルの中から `n_likes` カラムの値が `10` 以上のレコードを出力します。

### 7.3.54.4.4. 出力関連の引数

#### 7.3.54.4.4.1. `output_columns`

出力するカラムを `,` 区切りで指定します。

以下は簡単な `output_columns` の使用例です。

実行例:

    select Entries --output_columns '_id, _key' --limit 1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `_id` と `_key` カラムの値だけを出力します。

`*` は特別な値で 擬似カラム 以外のすべてのカラムという意味です。

以下は `*` の使用例です。

実行例:

    select Entries --output_columns '_key, *' --limit 1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `_key` 擬似カラム、 `content` カラム、 `n_likes` カラムの値を出力しますが、 `_id` 擬似カラムの値は出力しません。

デフォルト値は `_id, _key, *` です。これは `_score` 以外の全てのカラムを出力するという意味です。

#### 7.3.54.4.4.2. `sortby`

バージョン 6.0.3 で撤廃: 代わりに sort_keys を使ってください。

#### 7.3.54.4.4.3. `sort_keys`

ソートキーを `,` 区切りで指定します。それぞれのソートキーにはカラム名を指定します。

以下は簡単な `sort_keys` の使用例です。

実行例:

    select Entries --sort_keys 'n_likes, _id'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `n_likes` カラムの値で昇順にソートします。 `n_likes` の値が同じレコードについては `_id` カラムの値で昇順にソートします。 `"Good-bye Senna"` と `"Good-bye Tritonn"` が `_id` カラムの値でソートしているケースです。

降順でソートしたい場合はカラム名の前に `-` をつけてください。

以下は降順の `sort_keys` の使用例です。

実行例:

    select Entries --sort_keys '-n_likes, _id'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `n_likes` カラムの値で降順にソートします。しかし、 `_id` でソートするときは昇順でソートします。

もし、 `query` または `filter` 引数を使っているときは、 `sort_keys` の中で `_score` 擬似カラムを使うことができます。

実行例:

    select Entries --match_columns content --query fast --sort_keys -_score --output_columns '_key, _score'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Mroonga",
    #         2
    #       ],
    #       [
    #         "Groonga",
    #         1
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドはマッチしたレコードをヒットスコアで降順にソートし、レコードのキーとヒットスコアを出力します。

`query` 引数も `filter` 引数も指定しないで `_score` を使った場合は、 `_score` を無視して、ログファイルに警告を出力します。

#### 7.3.54.4.4.4. `offset`

出力するレコードの範囲を決めるためのオフセットを指定します。オフセットは0始まりです。 `--offset 1` は2番目以降のレコードを出力するという意味になります。

実行例:

    select Entries --sort_keys _id --offset 3 --output_columns _key
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "Good-bye Senna"
    #       ],
    #       [
    #         "Good-bye Tritonn"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは4番目以降のレコードを出力します。

負の値を指定することもできます。負の値の場合は `マッチしたレコード数 + offset` 番目のレコードから始まる範囲という意味になります。もし、マッチしたレコードが3つあり、 `--offset -2` を指定した場合は2番目（ `3 + -2 = 1` 。 `1` は2番目という意味です。オフセットは0始まりということを思い出してください。） のレコードから3番目のレコードを取得します。

実行例:

    select Entries --sort_keys _id --offset -2 --output_columns _key
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "Good-bye Senna"
    #       ],
    #       [
    #         "Good-bye Tritonn"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは4番目以降のレコードを出力します。なぜなら、全レコード数が `5` だからです。

デフォルト値は `0` です。

#### 7.3.54.4.4.5. `limit`

`limit` は出力レコード数の最大値を指定します。 もし、マッチしたレコード数が `limit` よりも小さい場合はすべてのレコードが出力されます。

以下は簡単な `limit` の使用例です。

実行例:

    select Entries --sort_keys _id --offset 2 --limit 3 --output_columns _key
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "Mroonga"
    #       ],
    #       [
    #         "Good-bye Senna"
    #       ],
    #       [
    #         "Good-bye Tritonn"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは3番目、4番目、5番目のレコードを出力します。

負の値を指定することもできます。負の値の場合は、最大で `マッチしたレコード数 + limit + 1` 件のレコードを出力するという意味になります。 例えば、 `--limit -1` はすべてのレコードを出力します。これはすべてのレコードを表示する場合にとても便利です。

以下は負の値を使った `limit` の簡単な使用例です。

実行例:

    select Entries --limit -1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドはすべてのレコードを出力します。

デフォルト値は `10` です。

#### 7.3.54.4.4.6. `scorer`

TODO: write in English and add example.

検索条件にマッチする全てのレコードに対して適用するgrn_exprをscript形式で指定します。

scorerは、検索処理が完了し、ソート処理が実行される前に呼び出されます。従って、各レコードのスコアを操作する式を指定しておけば、検索結果のソート順序をカスタマイズできるようになります。

### 7.3.54.4.5. 動的カラム関連の引数

バージョン 6.0.6 で追加.

このセクションは動的カラム関連の引数について説明します。ウィンドウ関数を使うために動的カラムを使うこともできますが、このセクションではウィンドウ関数については説明しません。ウィンドウ関数については ウィンドウ関数関連の引数 を参照してください。

`select` 実行中に0個以上のカラムを作ってそこに値を入れることができます。これらのカラムのことを「動的カラム」と呼びます。動的カラムが作られた後は通常のカラムと同じように使えます。

動的カラムは一度計算した値を使いまわすのでパフォーマンス上のメリットがあります。

動的カラムを使うとメモリー使用量が増えます。 `select` 実行中にカラムの値を保存し続ける必要があるからです。

以下のケースでは動的カラムを使う必要があります。

> - SQLの `AS` のように値に名前をつけたい場合。

> - 計算した値をドリルダウンしたい場合。Groongaにはドリルダウン中に値を計算する機能はありません。

> - ウィンドウ関数を使いたい場合。

いくつか動的カラムを作るタイミングがあります。各動的カラムには `stage` を指定する必要があります。これはどのタイミングで動的カラムを作るかを制御するためです。よりよい性能を出すために適切なタイミングを選ぶことが重要です。

たとえば、出力対象のレコードだけに必要な動的カラムを全レコードに対して作成することはオススメしません。通常、たとえテーブル内に大量のレコードがあったとしても、出力対象のレコードは少なくなります。これは、多くの場合は、テーブル内のレコードをフィルターしてソートしてレコード数を制限して、制限したレコードだけを出力するからです。

`stage` の詳細は columns[${NAME}].stage を見てください。

以下は動的カラムの引数です。ウィンドウ関数関連の引数は入っていません。ウィンドウ関数関連の引数については ウィンドウ関数関連の引数 を見てください。

名前 | デフォルト値 | 必須か省略可能か
--- | --- | ---
`columns[${NAME}].stage` | `null` | 必須
`columns[${NAME}].flags` | `COLUMN_SCALAR` | 省略可能
`columns[${NAME}].type` | `null` | 必須
`columns[${NAME}].value` | `null` | 必須

1つの動的カラムに対して複数のパラメーターを指定する必要があります。同じ `${NAME}` を使っているパラメーターは同じ動的カラムのパラメーターとして扱われます。以下は2つの動的カラム（ `name1` と `name2` ）用のパラメーターを指定する例です。:

    --columns[name1].stage initial
    --columns[name1].type UInt32
    --columns[name1].value 29

    --columns[name2].stage filtered
    --columns[name2].type ShortText
    --columns[name2].value "29"

#### 7.3.54.4.5.1. `columns[${NAME}].stage`

バージョン 6.0.6 で追加.

どのタイミング（どのステージ）で動的カラムを作るかを指定します。動的カラムを作る場合はこのパラメーターは必須です。

指定可能なステージは以下の通りです。

名前 | 説明
--- | ---
`initial` | 最初に動的カラムを作成します。
`filtered` | query と filter を評価してから動的カラムを作成します。
`output` | output_columns を評価する前に動的カラムを作成します。

以下は動的カラム作成タイミング入りの `select` の処理の流れです。できるだけ後のステージを選ぶべきです。

> 1. `initial` ステージの動的カラムを作ります。すべてのレコードはこの動的カラムを持ちます。

> 2. query と filter を評価します。 `initial` ステージで作った動的カラムを使えます。

> 3. `filtered` ステージの動的カラムを作ります。フィルター後のレコードだけがこの動的カラムを持ちます。

> 4. adjuster を評価します。 `initial` ステージと `filtered` ステージで作った動的カラムを使えます。

> 5. scorer を評価します。 `initial` ステージと `filtered` ステージで作った動的カラムを使えます。

> 6. sort_keys 、 offset 、 limit を評価します。 `initial` ステージと `filtered` ステージで作った動的カラムを使えます。

> 7. スライス関連の引数 を評価します。 `initial` ステージと `filtered` ステージで作った動的カラムを使えます。

> 8. ドリルダウン関連の引数 と 高度なドリルダウン関連のパラメーター を評価します。 `initial` ステージと `filtered` ステージで作った動的カラムを使えます。各ドリルダウン内でも個別に動的カラムを作れるので混同しないように注意してください。

> 9. `output` ステージの動的カラムを作ります。最大 limit 件のレコードだけがこの動的カラムを持ちます。

> 10. output_columns を評価します。 `initial` ステージと `filtered` ステージと `output` ステージで作った動的カラムを使えます。

以下は `initial` ステージで `is_popular` カラムを作る例です。作成した `is_popular` カラムは `filter` や `output_columns` を含むすべてのパラメーターで使えます。

実行例:

    select Entries \
      --columns[is_popular].stage initial \
      --columns[is_popular].type Bool \
      --columns[is_popular].value 'n_likes >= 10' \
      --filter is_popular \
      --output_columns _id,is_popular,n_likes
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "is_popular",
    #           "Bool"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         2,
    #         true,
    #         10
    #       ],
    #       [
    #         3,
    #         true,
    #         15
    #       ]
    #     ]
    #   ]
    # ]

#### 7.3.54.4.5.2. `columns[${NAME}].flags`

バージョン 6.0.6 で追加.

動的カラムのフラグを指定します。これは column_create の `flags` パラメーターと同じです。利用可能なフラグは flags を見てください。

デフォルト値は `COLUMN_SCALAR` です。

以下は `columns[${NAME}].flags` の使用例です。この例では `COLUMN_VECTOR` フラグを指定してベクターカラムを作成しています。 `plugin_register functions/vector` は vector_new 関数を使うために実行しています。:

実行例:

    plugin_register functions/vector
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    select Entries \
      --columns[vector].stage initial \
      --columns[vector].flags COLUMN_VECTOR \
      --columns[vector].type UInt32 \
      --columns[vector].value 'vector_new(1, 2, 3)' \
      --output_columns _id,vector
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "vector",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         [
    #           1,
    #           2,
    #           3
    #         ]
    #       ],
    #       [
    #         2,
    #         [
    #           1,
    #           2,
    #           3
    #         ]
    #       ],
    #       [
    #         3,
    #         [
    #           1,
    #           2,
    #           3
    #         ]
    #       ],
    #       [
    #         4,
    #         [
    #           1,
    #           2,
    #           3
    #         ]
    #       ],
    #       [
    #         5,
    #         [
    #           1,
    #           2,
    #           3
    #         ]
    #       ]
    #     ]
    #   ]
    # ]

#### 7.3.54.4.5.3. `columns[${NAME}].type`

バージョン 6.0.6 で追加.

動的カラムの値の型を指定します。 column_create の `type` パラメーターと同じです。利用可能な型は type を見てください。

必須の引数です。

以下は `ShortText` 型のカラムを作る例です。保存された値は自動的に `ShortText` にキャストされます。この例では数値が `ShortText` にキャストされています。

実行例:

    select Entries \
      --columns[n_likes_string].stage initial \
      --columns[n_likes_string].type ShortText \
      --columns[n_likes_string].value n_likes \
      --output_columns _id,n_likes,n_likes_string
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes_string",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         5,
    #         "5"
    #       ],
    #       [
    #         2,
    #         10,
    #         "10"
    #       ],
    #       [
    #         3,
    #         15,
    #         "15"
    #       ],
    #       [
    #         4,
    #         3,
    #         "3"
    #       ],
    #       [
    #         5,
    #         3,
    #         "3"
    #       ]
    #     ]
    #   ]
    # ]

#### 7.3.54.4.5.4. `columns[${NAME}].value`

バージョン 6.0.6 で追加.

この動的カラムの値を生成する式を指定します。式には スクリプト構文 を使います。この構文は filter と同じです。たとえば、 `1 + 1` 、 `string_length("Hello")` 、 `column * 1.08` などは妥当な式です。

ウィンドウ関数を使う場合は、 `value` の値に ウィンドウ関数 を指定し、他のウィンドウ関数のパラメーターも指定する必要があります。詳細は ウィンドウ関数関連の引数 を見てください。

必須の引数です。

以下は内容の文字数を格納するための動的カラムを1つ作る例です。この例では文字数を数えるために `functions/string` プラグイン内の string_length 関数を使っています。 `functions/string` プラグインを登録するために plugin_register を使っています。

実行例:

    plugin_register functions/string
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    select Entries \
      --columns[content_length].stage initial \
      --columns[content_length].type UInt32 \
      --columns[content_length].value 'string_length(content)' \
      --output_columns _id,content,content_length
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "content_length",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         "Welcome! This is my first post!",
    #         31
    #       ],
    #       [
    #         2,
    #         "I started to use Groonga. It's very fast!",
    #         41
    #       ],
    #       [
    #         3,
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         64
    #       ],
    #       [
    #         4,
    #         "I migrated all Senna system!",
    #         28
    #       ],
    #       [
    #         5,
    #         "I also migrated all Tritonn system!",
    #         35
    #       ]
    #     ]
    #   ]
    # ]

### 7.3.54.4.6. ウィンドウ関数関連の引数

バージョン 6.0.6 で追加.

このセクションはウィンドウ関数関連の引数について説明します。ウィンドウ関数を使うためには動的カラムを使う必要があります。動的カラムについては 動的カラム関連の引数 を見てください。

Groongaのウィンドウ関数はSQLのウィンドウ関数と似ています。通常の関数は現在のレコードだけを使って結果を計算します。一方、ウィンドウ関数は複数のレコードを使って結果を計算します。複数のレコードを処理できるのでウィンドウ関数はデータ解析に有用です。

サポートしているウィンドウ関数は ウィンドウ関数 で確認できます。たとえば、 window_sum はウィンドウ関数です。このウィンドウ関数は対象レコードの数値の合計を計算します。

ウィンドウ関数は指定したグループキーでグループ化したレコードを処理します。たとえば、以下のケースではウィンドウ関数は3つのグループ（ `Hello` グループ、 `Groonga` グループ、 `Senna` グループ）を処理します。 window_sum は各グループ毎に `n_likes` の値の合計を計算します。

グループ番号 | グループキーの値 | `n_likes` の値 | window_sum の結果
--- | --- | --- | ---
1 | `Hello` | 5 | 5
2 | `Groonga` | 10 | 25
2 | `Groonga` | 15 | 25
3 | `Senna` | 3 | 6
3 | `Senna` | 3 | 6

グループキーを指定しないこともできます。この場合、ウィンドウ関数はすべてのレコードを含んだ1つのグループだけを処理します。以下のケースでは window_sum はすべての `n_likes` の値の合計を計算します。

グループ番号 | `n_likes` の値 | window_sum の結果
--- | --- | ---
1 | 5 | 36
1 | 10 | 36
1 | 15 | 36
1 | 3 | 36
1 | 3 | 36

ウィンドウ関数は各グループのレコードを指定された順に処理します。前述のグループキーの例のようにソートキーを指定しないこともできます。

ソートキーを指定しなかったときの挙動は各ウィンドウ関数の仕様に依存します。たとえば、 window_sum はソートキーを指定したときと指定しないときで挙動が変わります。ソートキーを指定しなかったときは、 window_sum はグループの全レコードの値の合計を計算し、すべての対象レコードに合計値を格納します。これは前述のグループキーの例での挙動です。ソートキーを指定したときは、 window_sum は累積和を計算します。 window_sum はグループの全レコードの合計を順番に計算し、各レコードにはそのレコードを処理した時点の合計値を格納します。以下に例を示します。

グループ番号 | グループキーの値 | ソートキーの値 | `n_likes` の値 | window_sum の結果 | 備考
--- | --- | --- | --- | --- | ---
1 | `Hello` | 1 | 5 | 5 | グループ番号1の最初のレコード。（ `5 = 5` ）
2 | `Groonga` | 90 | 10 | 10 | グループ番号2の最初のレコード。（ `10 = 10` ）
2 | `Groonga` | 91 | 15 | 25 | グループ番号2の2つ目のレコード。（ `10 + 15 = 25` ）
3 | `Senna` | 200 | 3 | 8 | グループ番号3の2つ目のレコード。（ `5 + 3 = 8` ）
3 | `Senna` | 100 | 5 | 5 | グループ番号3の最初のレコード。（ `5 = 5` ）

以下はウィンドウ関数のパラメーターです。ウィンドウ関数関連のパラメーターと動的カラム関連のパラメーターを指定する必要があります。なぜならウィンドウ関数は動的カラムの上に実装されているからです。動的カラム関連のパラメーターについては 動的カラム関連の引数 を見てください。

名前 | 必須か省略可能か | 備考
--- | --- | ---
`columns[${NAME}].value` | 必須 | ウィンドウ関数 を使います。
`columns[${NAME}].window.sort_keys` | `columns[${NAME}].window.group_keys` を指定しない場合は必須です。 |
`columns[${NAME}].window.group_keys` | `columns[${NAME}].window.sort_keys` を指定しない場合は必須です。 |

#### 7.3.54.4.6.1. `columns[${NAME}].window.sort_keys`

バージョン 6.0.6 で追加.

各グループでのソートキーを指定します。ウィンドウ関数は各グループのレコードを指定された順に処理します。

ソートキーを `,` 区切りで指定します。それぞれのソートキーにはカラム名を指定します。これは sort_keys と同じです。

ウィンドウ関数を使う場合は columns[${NAME}].window.sort_keys または columns[${NAME}].window.group_keys を使う必要があります。

以下は `Entries.tag` 毎に累積和を計算する例です。各グループ内のレコードは `Entries._key` でソートします。

実行例:

    select \
      --table Entries \
      --columns[n_likes_cumulative_sum_per_tag].stage initial \
      --columns[n_likes_cumulative_sum_per_tag].type UInt32 \
      --columns[n_likes_cumulative_sum_per_tag].value 'window_sum(n_likes)' \
      --columns[n_likes_cumulative_sum_per_tag].window.sort_keys _key \
      --columns[n_likes_cumulative_sum_per_tag].window.group_keys tag \
      --sort_keys _key \
      --output_columns tag,_key,n_likes,n_likes_cumulative_sum_per_tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "tag",
    #           "ShortText"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes_cumulative_sum_per_tag",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         "Senna",
    #         "Good-bye Senna",
    #         3,
    #         3
    #       ],
    #       [
    #         "Senna",
    #         "Good-bye Tritonn",
    #         3,
    #         6
    #       ],
    #       [
    #         "Groonga",
    #         "Groonga",
    #         10,
    #         10
    #       ],
    #       [
    #         "Groonga",
    #         "Mroonga",
    #         15,
    #         25
    #       ],
    #       [
    #         "Hello",
    #         "The first post!",
    #         5,
    #         5
    #       ]
    #     ]
    #   ]
    # ]

#### 7.3.54.4.6.2. `columns[${NAME}].window.group_keys`

バージョン 7.0.0 で追加.

グループキーを指定します。ウィンドウ関数は各グループのレコードを処理します。グループキーを指定しない場合はウィンドウ関数はすべてのレコードを含んだ1つのグループを処理します。

グループキーを `,` 区切りで指定します。それぞれのグループキーにはカラム名を指定します。これは drilldown と同じです。

ウィンドウ関数を使う場合は columns[${NAME}].window.sort_keys または columns[${NAME}].window.group_keys を使う必要があります。

以下は `Entries.tag` 毎に合計を計算する例です。

実行例:

    select \
      --table Entries \
      --columns[n_likes_sum_per_tag].stage initial \
      --columns[n_likes_sum_per_tag].type UInt32 \
      --columns[n_likes_sum_per_tag].value 'window_sum(n_likes)' \
      --columns[n_likes_sum_per_tag].window.group_keys tag \
      --sort_keys _key \
      --output_columns tag,_key,n_likes,n_likes_sum_per_tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "tag",
    #           "ShortText"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes_sum_per_tag",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         "Senna",
    #         "Good-bye Senna",
    #         3,
    #         6
    #       ],
    #       [
    #         "Senna",
    #         "Good-bye Tritonn",
    #         3,
    #         6
    #       ],
    #       [
    #         "Groonga",
    #         "Groonga",
    #         10,
    #         25
    #       ],
    #       [
    #         "Groonga",
    #         "Mroonga",
    #         15,
    #         25
    #       ],
    #       [
    #         "Hello",
    #         "The first post!",
    #         5,
    #         5
    #       ]
    #     ]
    #   ]
    # ]

### 7.3.54.4.7. ドリルダウン関連の引数

このセクションでは基本的なドリルダウン関連の引数について説明します。高度なドリルダウン関連の引数は他のセクションで説明します。

#### 7.3.54.4.7.1. `drilldown`

グループ化するときに使うキーを `,` 区切りで指定します。

指定した検索条件にマッチしたレコードを指定したキーのそれぞれでグループ化します。検索条件を指定していない場合はすべてのレコードを指定したキーのそれぞれでグループ化します。

以下は簡単な `drilldown` の使用例です。

実行例:

    select Entries \
      --output_columns _key,tag \
      --drilldown tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Hello"
    #       ],
    #       [
    #         "Groonga",
    #         "Groonga"
    #       ],
    #       [
    #         "Mroonga",
    #         "Groonga"
    #       ],
    #       [
    #         "Good-bye Senna",
    #         "Senna"
    #       ],
    #       [
    #         "Good-bye Tritonn",
    #         "Senna"
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは次の情報を出力します。

> - 「Hello」タグを持つレコードが1つある。

> - 「Groonga」タグを持つレコードが2つある。

> - 「Senna」タグを持つレコードが2つある。

以下は検索条件付きで `drilldown` を使う例です。

実行例:

    select Entries \
      --output_columns _key,tag \
      --filter 'n_likes >= 5' \
      --drilldown tag
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Hello"
    #       ],
    #       [
    #         "Groonga",
    #         "Groonga"
    #       ],
    #       [
    #         "Mroonga",
    #         "Groonga"
    #       ]
    #     ],
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは次の情報を出力します。

> - `n_likes` の値が5以上のレコードの中には…

>   - 「Hello」タグを持つレコードが1つある。

>   - 「Groonga」タグを持つレコードが2つある。

以下は複数のグループ化キーを指定する `drilldown` の例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag,n_likes
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ],
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_key",
    #           "UInt32"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         5,
    #         1
    #       ],
    #       [
    #         10,
    #         1
    #       ],
    #       [
    #         15,
    #         1
    #       ],
    #       [
    #         3,
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは次の情報を出力します。

> - `tag` について:

>   - 「Hello」タグを持つレコードが1つある。

>   - 「Groonga」タグを持つレコードが2つある。

>   - 「Senna」タグを持つレコードが2つある。

> - `n_likes` について:

>   - 「Hello」タグを持つレコードが1つある。

>   - 「Groonga」タグを持つレコードが2つある。

>   - 「Senna」タグを持つレコードが2つある。

#### 7.3.54.4.7.2. `drilldown_sortby`

バージョン 6.0.3 で撤廃: drilldown_sort_keys を代わりに使ってください

#### 7.3.54.4.7.3. `drilldown_sort_keys`

ドリルダウン結果のソートキーを `,` 区切りで指定します。それぞれのソートキーはカラム名を指定します。

グループ化されたレコード数は `_nsubrecs` 擬似カラム 擬似カラムで参照できます。

以下は簡単な `drilldown_sort_keys` の使用例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown 'tag, n_likes' \
      --drilldown_sort_keys '-_nsubrecs, _key'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ]
    #     ],
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_key",
    #           "UInt32"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         3,
    #         2
    #       ],
    #       [
    #         5,
    #         1
    #       ],
    #       [
    #         10,
    #         1
    #       ],
    #       [
    #         15,
    #         1
    #       ]
    #     ]
    #   ]
    # ]

ドリルダウン結果は「グループに含まれるレコード数」（= `_nsubrecs` ）で降順にソートします。「グループに含まれるレコード数」が同じグループが複数あった場合は、グループ化に使ったキー（= `_key` ）で昇順にソートします。

`drilldown` で指定したすべてのグループキーで同じソートキーを使います。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown 'tag, n_likes' \
      --drilldown_sort_keys '-_nsubrecs, _key'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ]
    #     ],
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_key",
    #           "UInt32"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         3,
    #         2
    #       ],
    #       [
    #         5,
    #         1
    #       ],
    #       [
    #         10,
    #         1
    #       ],
    #       [
    #         15,
    #         1
    #       ]
    #     ]
    #   ]
    # ]

`tag` のドリルダウンでも `n_likes` のドリルダウンでも同じソートキーを使っています。

それぞれのドリルダウンで異なるソートキーを使いたい場合は 高度なドリルダウン関連のパラメーター を参照してください。

#### 7.3.54.4.7.4. `drilldown_output_columns`

ドリルダウン結果から出力するカラムを `,` 区切りで指定します。

以下は `drilldown_output_columns` の使用例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_output_columns _key
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "Hello"
    #       ],
    #       [
    #         "Groonga"
    #       ],
    #       [
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドはグループ化したキーを出力していくだけです。

グループ化したキーが参照型のカラム（型がテーブルのカラム）だった場合、参照型のカラムが参照しているテーブルのカラムにもアクセスできます。

参照型に対してドリルダウンする方法を示すために使うスキーマ定義とサンプルデータは以下の通りです。

実行例:

    table_create Tags TABLE_HASH_KEY ShortText --normalizer NormalizerAuto
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Tags label COLUMN_SCALAR ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Tags priority COLUMN_SCALAR Int32
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    table_create Items TABLE_HASH_KEY ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Items tag COLUMN_SCALAR Tags
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table Tags
    [
    {"_key": "groonga", label: "Groonga", priority: 10},
    {"_key": "mroonga", label: "Mroonga", priority: 5}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 2]
    load --table Items
    [
    {"_key": "A", "tag": "groonga"},
    {"_key": "B", "tag": "groonga"},
    {"_key": "C", "tag": "mroonga"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 3]

`Tags` テーブルは参照されているテーブルです。 `Items.tag` は参照型のカラムです。

`Tags.label` は `drilldown_output_columns` の中では `label` で参照できます。

実行例:

    select Items \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_output_columns '_key, label'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "label",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         "groonga",
    #         "Groonga"
    #       ],
    #       [
    #         "mroonga",
    #         "Mroonga"
    #       ]
    #     ]
    #   ]
    # ]

`*` を使うと、参照されているテーブル（= `Tags` ）のすべてのカラムを参照できます。

実行例:

    select Items \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_output_columns '_key, *'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "label",
    #           "ShortText"
    #         ],
    #         [
    #           "priority",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "groonga",
    #         "Groonga",
    #         10
    #       ],
    #       [
    #         "mroonga",
    #         "Mroonga",
    #         5
    #       ]
    #     ]
    #   ]
    # ]

`*` は `label, priority` に展開されます。

`drilldown_output_columns` のデフォルト値は `_key, _nsubrecs` です。グループ化に使ったキーとグループのレコード数を出力する、ということです。

drilldown_calc_types を使うと、 `drilldown_output_columns` の中で `_max` 、 `_min` 、 `_sum` 、 `_avg` といった 擬似カラム も使えるようになります。詳細は `drilldown_calc_types` のドキュメントを参照してください。

#### 7.3.54.4.7.5. `drilldown_offset`

ドリルダウン結果を出力するレコードの範囲を決めるためのオフセットを指定します。オフセットは0始まりです。 `--offset 1` は2番目以降のレコードを出力するという意味になります。

以下は簡単な `drilldown_offset` の使用例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_sort_keys _key \
      --drilldown_offset 1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは2番目以降のレコードを出力します。

負の値を指定することもできます。負の値の場合は `グループの数 + offset` 番目のレコードから始まる範囲という意味になります。もし、グループの数が3つあり、 `--offset -2` を指定した場合は1番目（ `3 + -2 = 1` 。 `1` は2番目です。オフセットは0始まりということを思い出してください。） のグループから3番目のグループが出力されます。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_sort_keys _key \
      --drilldown_offset -2
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは2番目以降のグループを出力します。なぜなら、全グループ数が `3` だからです。

`drilldown_offset` のデフォルト値は `0` です。

#### 7.3.54.4.7.6. `drilldown_limit`

`drilldown_limit` は出力グループ数の最大値を指定します。もし、グループ数 `limit` よりも小さい場合はすべてのグループが出力されます。

以下は `drilldown_limit` の使用例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_sort_keys _key \
      --drilldown_offset 1 \
      --drilldown_limit 2
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは2番目、3番目のレコードを出力します。

負の値を指定することもできます。負の値の場合は、最大で `マッチしたレコード数 + drilldown_limit + 1` 件のレコードを出力するという意味になります。 例えば、 `--drilldown_limit -1` はすべてのレコードを出力します。これはすべてのレコードを表示する場合にとても便利です。

以下は `drilldown_limit` に負の値を指定する例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldown tag \
      --drilldown_sort_keys _key \
      --drilldown_limit -1
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Hello",
    #         1
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドはすべてのグループを出力します。

`drilldown_limit` のデフォルト値は `10` です。

#### 7.3.54.4.7.7. `drilldown_calc_types`

ドリルダウンでグループ内のレコードの値を計算（集計）する方法を指定します。「 `,` 」で区切ることで複数の計算タイプを指定することもできます。たとえば、 `MAX,MIN` といった具合です。

計算対象の値はグループ内のレコードのカラムから取得します。このカラムは drilldown_calc_target で指定します。

計算した値は drilldown_output_columns の中で `_max` や `_min` のような 擬似カラム を指定すると取得できます。

以下の計算タイプを使えます。

タイプ名 | 擬似カラム 名 | drilldown_calc_target が必要か | 説明
--- | --- | --- | ---
`NONE` | なし。 | 必要ない。 | 無視されます。
`COUNT` | `_nsubrecs` | 必要ない。 | グループ内のレコードの数を数える。常に有効なので指定する必要はない。
`MAX` | `_max` | 必要。 | グループ内のレコードの整数値の中で最大の値を見つける。
`MIN` | `_min` | 必要。 | グループ内のレコードの整数値の中で最小の値を見つける。
`SUM` | `_sum` | 必要。 | グループ内のレコードの整数値の合計を計算する。
`AVG` | `_avg` | 必要。 | グループ内のレコードの整数値・浮動小数点数値の平均を計算する。

以下は `MAX` の使用例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,n_likes \
      --drilldown tag \
      --drilldown_calc_types MAX \
      --drilldown_calc_target n_likes \
      --drilldown_output_columns _key,_max
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         5
    #       ],
    #       [
    #         2,
    #         10
    #       ],
    #       [
    #         3,
    #         15
    #       ],
    #       [
    #         4,
    #         3
    #       ],
    #       [
    #         5,
    #         3
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_max",
    #           "Int64"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5
    #       ],
    #       [
    #         "Groonga",
    #         15
    #       ],
    #       [
    #         "Senna",
    #         3
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `tag` カラムの値ですべてのレコードをグループ化します。その後、各グループについて最大の `n_likes` カラムの値を探し、「グループ化に使ったキー」と「 `n_likes` カラムの値の最大値」のペアのリストを出力します。 `n_likes` カラムの値の最大値を参照するために `_max` 擬似カラム を使っています。

以下は `MIN` の使用例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,n_likes \
      --drilldown tag \
      --drilldown_calc_types MIN \
      --drilldown_calc_target n_likes \
      --drilldown_output_columns _key,_min
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         5
    #       ],
    #       [
    #         2,
    #         10
    #       ],
    #       [
    #         3,
    #         15
    #       ],
    #       [
    #         4,
    #         3
    #       ],
    #       [
    #         5,
    #         3
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_min",
    #           "Int64"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5
    #       ],
    #       [
    #         "Groonga",
    #         10
    #       ],
    #       [
    #         "Senna",
    #         3
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `tag` カラムの値ですべてのレコードをグループ化します。その後、各グループについて最小の `n_likes` カラムの値を探し、「グループ化に使ったキー」と「 `n_likes` カラムの値の最小値」のペアのリストを出力します。 `n_likes` カラムの値の最小値を参照するために `_min` 擬似カラム を使っています。

以下は `SUM` の使用例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,n_likes \
      --drilldown tag \
      --drilldown_calc_types SUM \
      --drilldown_calc_target n_likes \
      --drilldown_output_columns _key,_sum
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         5
    #       ],
    #       [
    #         2,
    #         10
    #       ],
    #       [
    #         3,
    #         15
    #       ],
    #       [
    #         4,
    #         3
    #       ],
    #       [
    #         5,
    #         3
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_sum",
    #           "Int64"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5
    #       ],
    #       [
    #         "Groonga",
    #         25
    #       ],
    #       [
    #         "Senna",
    #         6
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `tag` カラムの値ですべてのレコードをグループ化します。その後、各グループについて `n_likes` カラムの合計を計算し、「グループ化に使ったキー」と「 `n_likes` カラムの値の合計」のペアのリストを出力します。 `n_likes` カラムの値の合計を参照するために `_sum` 擬似カラム を使っています。

以下は `AVG` の使用例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,n_likes \
      --drilldown tag \
      --drilldown_calc_types AVG \
      --drilldown_calc_target n_likes \
      --drilldown_output_columns _key,_avg
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         5
    #       ],
    #       [
    #         2,
    #         10
    #       ],
    #       [
    #         3,
    #         15
    #       ],
    #       [
    #         4,
    #         3
    #       ],
    #       [
    #         5,
    #         3
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_avg",
    #           "Float"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5.0
    #       ],
    #       [
    #         "Groonga",
    #         12.5
    #       ],
    #       [
    #         "Senna",
    #         3.0
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは `tag` カラムの値ですべてのレコードをグループ化します。その後、各グループについて `n_likes` カラムの平均を計算し、「グループ化に使ったキー」と「 `n_likes` カラムの値の平均」のペアのリストを出力します。 `n_likes` カラムの値の合計を参照するために `_avg` 擬似カラム を使っています。

以下はすべての計算タイプを使う例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,n_likes \
      --drilldown tag \
      --drilldown_calc_types MAX,MIN,SUM,AVG \
      --drilldown_calc_target n_likes \
      --drilldown_output_columns _key,_nsubrecs,_max,_min,_sum,_avg
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         1,
    #         5
    #       ],
    #       [
    #         2,
    #         10
    #       ],
    #       [
    #         3,
    #         15
    #       ],
    #       [
    #         4,
    #         3
    #       ],
    #       [
    #         5,
    #         3
    #       ]
    #     ],
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ],
    #         [
    #           "_max",
    #           "Int64"
    #         ],
    #         [
    #           "_min",
    #           "Int64"
    #         ],
    #         [
    #           "_sum",
    #           "Int64"
    #         ],
    #         [
    #           "_avg",
    #           "Float"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         1,
    #         5,
    #         5,
    #         5,
    #         5.0
    #       ],
    #       [
    #         "Groonga",
    #         2,
    #         15,
    #         10,
    #         25,
    #         12.5
    #       ],
    #       [
    #         "Senna",
    #         2,
    #         3,
    #         3,
    #         6,
    #         3.0
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドは複数の計算タイプを `MAX,MIN,SUM,AVG` というように「 `,` 」で区切って指定しています。 drilldown_output_columns で `COUNT` を指定していなくても `_nsubrecs` 擬似カラム を使えます。これは、 `COUNT` は常に有効だからです。

`drilldown_calc_types` のデフォルト値は `NONE` です。これは、 `COUNT` だけが有効になっているという意味です。なぜなら、 `NONE` は単に無視されて、 `COUNT` は常に有効だからです。

#### 7.3.54.4.7.8. `drilldown_calc_target`

バージョン 6.0.3 で追加.

drilldown_calc_types の計算対象のカラムを指定します。

drilldown_calc_types で `MAX` のように計算対象のカラムが必要な計算タイプを指定したにも関わらず `drilldown_calc_target` を省略すると、計算結果は常に `0` になります。

`--drilldown_calc_target n_likes` というように1つのカラム名だけしか指定できません。 `--drilldown_calc_target _key,n_likes` というように複数のカラムを指定することはできません。

`--drilldown_calc_target reference_column.nested_reference_column.value` というように「 `.` 」でつなげることで対象レコードから参照している値を使うことができます。

`drilldown_calc_target` の使い方は drilldown_calc_types を参照してください。

`drilldown_calc_target` のデフォルト値は `null` です。これは計算対象カラムは何も指定されていないということです。

#### 7.3.54.4.7.9. `drilldown_filter`

バージョン 6.0.3 で追加.

ドリルダウン結果に対するフィルター条件を指定します。

構文は スクリプト構文 です。これは filter と同じです。

以下は1開始か出現していないタグを除く例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns _id,tag \
      --drilldown tag \
      --drilldown_filter '_nsubrecs > 1' \
      --drilldown_output_columns _key,_nsubrecs
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Senna"
    #       ]
    #     ],
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "_nsubrecs",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "Groonga",
    #         2
    #       ],
    #       [
    #         "Senna",
    #         2
    #       ]
    #     ]
    #   ]
    # ]

### 7.3.54.4.8. 高度なドリルダウン関連のパラメーター

バージョン 4.0.8 で追加.

drilldown に複数のグループキーを指定することで複数のドリルダウン結果を取得できます。しかし、すべてのドリルダウンで同じ設定を使う必要があります。例えば、すべてのドリルダウンで同じ drilldown_output_columns の値が使われます。

以下の引数を使うことで、各ドリルダウンで別々の設定を使うことができます。

> - `drilldowns[${LABEL}].keys`
> - `drilldowns[${LABEL}].sort_keys`
> - `drilldowns[${LABEL}].output_columns`
> - `drilldowns[${LABEL}].offset`
> - `drilldowns[${LABEL}].limit`
> - `drilldowns[${LABEL}].calc_types`
> - `drilldowns[${LABEL}].calc_target`
> - `drilldowns[${LABEL}].filter`
> - `drilldowns[${LABEL}].columns[${NAME}].stage=null`
> - `drilldowns[${LABEL}].columns[${NAME}].flags=COLUMN_SCALAR`
> - `drilldowns[${LABEL}].columns[${NAME}].type=null`
> - `drilldowns[${LABEL}].columns[${NAME}].value=null`
> - `drilldowns[${LABEL}].columns[${NAME}].window.sort_keys=null`
> - `drilldowns[${LABEL}].columns[${NAME}].window.group_keys=null`

`${LABEL}` は変数です。 `${LABEL}` には次の文字を使うことができます。

> - アルファベット

> - 数字

> - `.`
> - `_`

`${NAME}` は変数です。 `${NAME}` には次の文字を使うことができます。

> - アルファベット

> - 数字

> - `_`

注釈

他の文字も使えますが、これらの文字だけを使ってください。

同じ `${LABEL}` の値を持つ引数は同じグループになります。1つのドリルダウンで同じグループの引数を一緒に使います。

例えば、以下の引数は2つのグループにわかれます。

> - `--drilldowns[label1].keys _key`
> - `--drilldowns[label1].output_columns _nsubrecs`
> - `--drilldowns[label2].keys tag`
> - `--drilldowns[label2].output_columns _key,_nsubrecs`

`drilldowns[label1].keys` と `drilldowns[label1].output_columns` が同じグループです。 `drilldowns[label2].keys` と `drilldowns[label2].output_columns` は別のグループです。

`label1` グループでは、グループキーとして `_key` を使って、出力カラムとして `_nsubrecs` を使います。

`label2` グループでは、グループキーとして `tag` を使って、出力カラムとして `_key,_nsubrecs` を使います。

以下の引数の使い方は対応する `drilldown_XXX` 引数のドキュメントを参照してください。

> - `drilldowns[${LABEL}].sort_keys`: drilldown_sort_keys
> - `drilldowns[${LABEL}].offset`: drilldown_offset
> - `drilldowns[${LABEL}].limit`: drilldown_limit
> - `drilldowns[${LABEL}].calc_types`: drilldown_calc_types
> - `drilldowns[${LABEL}].calc_target`: drilldown_calc_target
> - `drilldowns[${LABEL}].filter`: drilldown_filter

以下の引数の使い方は対応する `columns[${NAME}].XXX` 引数のドキュメントを参照してください。

> - `drilldowns[${LABEL}].columns[${NAME}].flags=COLUMN_SCALAR`: columns[${NAME}].flags
> - `drilldowns[${LABEL}].columns[${NAME}].type=null`: columns[${NAME}].type
> - `drilldowns[${LABEL}].columns[${NAME}].value=null`: columns[${NAME}].value
> - `drilldowns[${LABEL}].columns[${NAME}].window.sort_keys=null`: columns[${NAME}].window.sort_keys
> - `drilldowns[${LABEL}].columns[${NAME}].window.group_keys=null`: columns[${NAME}].window.group_keys

以下の引数は追加の説明が必要です。

> - `drilldowns[${LABEL}].keys`
> - `drilldowns[${LABEL}].output_columns`
> - `drilldowns[${LABEL}].columns[${NAME}].stage=null`

出力フォーマットは少し違います。これも追加の説明が必要です。

#### 7.3.54.4.8.1. `drilldowns[${LABEL}].keys`

バージョン 4.0.8 で追加.

drilldown は複数のキーを指定して複数のドリルダウンを指定できます。しかし、1つのドリルダウンに複数のキーを指定することはできません。

`drilldowns[${LABEL}].keys` は複数のキーを指定して複数のドリルダウンを指定することはできません。しかし、1つのドリルダウンに複数のキーを指定することができます。

複数のキーを「`,` 」区切りで指定します。

以下は `tag` カラムと `n_likes` カラムの値を使った複数キーでのグループ化の例です。

実行例:

    select Entries \
      --limit -1 \
      --output_columns tag,n_likes \
      --drilldowns[tag.n_likes].keys tag,n_likes \
      --drilldowns[tag.n_likes].output_columns _value.tag,_value.n_likes,_nsubrecs
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "tag",
    #           "ShortText"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         "Hello",
    #         5
    #       ],
    #       [
    #         "Groonga",
    #         10
    #       ],
    #       [
    #         "Groonga",
    #         15
    #       ],
    #       [
    #         "Senna",
    #         3
    #       ],
    #       [
    #         "Senna",
    #         3
    #       ]
    #     ],
    #     {
    #       "tag.n_likes": [
    #         [
    #           4
    #         ],
    #         [
    #           [
    #             "tag",
    #             "ShortText"
    #           ],
    #           [
    #             "n_likes",
    #             "UInt32"
    #           ],
    #           [
    #             "_nsubrecs",
    #             "Int32"
    #           ]
    #         ],
    #         [
    #           "Hello",
    #           5,
    #           1
    #         ],
    #         [
    #           "Groonga",
    #           10,
    #           1
    #         ],
    #         [
    #           "Groonga",
    #           15,
    #           1
    #         ],
    #         [
    #           "Senna",
    #           3,
    #           2
    #         ]
    #       ]
    #     }
    #   ]
    # ]

`tag.n_likes` はドリルダウン引数グループのラベルです。グループ化に使ったそれぞれのキーを参照するときは drilldowns[${LABEL}].output_columns で `_value.${KEY_NAME}` という構文を使います。 `${KEY_NAME}` にはグループキーを指定したときに使ったカラム名を使います。この場合は `${KEY_NAME}` に `tag` と `n_keys` を使います。

`--drilldowns[tag].keys tag` のように `drilldowns[${LABEL}].keys` にキーを1つだけしか指定していない場合は `_value.${KEY_NAME}` 構文を使うことはできません。この場合は `_key` を使ってください。これは、 drilldown_output_columns と同じルールです。

#### 7.3.54.4.8.2. `drilldowns[${LABEL}].output_columns`

バージョン 4.0.8 で追加.

`drilldowns[${LABEL}].output_columns` はほとんど drilldown_output_columns と同じです。 drilldown_output_columns と `drilldowns[${LABEL}].output_columns` の違いはグループキーの参照方法です。

drilldown_output_columns はグループキーを参照するために `_key` 擬似カラム を使います。 `drilldowns[${LABEL}].output_columns` も drilldowns[${LABEL}].keys で1つだけしかグループキーを指定していない場合は、グループキーを参照するために `_key` 擬似カラム を使います。

以下は1つだけ指定したグループキーを参照するために `_key` 擬似カラム を使う例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldowns[tag.n_likes].keys tag,n_likes \
      --drilldowns[tag.n_likes].output_columns _value.tag,_value.n_likes
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     {
    #       "tag.n_likes": [
    #         [
    #           4
    #         ],
    #         [
    #           [
    #             "tag",
    #             "ShortText"
    #           ],
    #           [
    #             "n_likes",
    #             "UInt32"
    #           ]
    #         ],
    #         [
    #           "Hello",
    #           5
    #         ],
    #         [
    #           "Groonga",
    #           10
    #         ],
    #         [
    #           "Groonga",
    #           15
    #         ],
    #         [
    #           "Senna",
    #           3
    #         ]
    #       ]
    #     }
    #   ]
    # ]

`drilldownss[${LABEL}].output_columns` で各グループキーを参照するために `_key` 擬似カラム を使うことはできません。 `_value.${KEY_NAME}` 構文を使います。 `${KEY_NAME}` には drilldowns[${LABEL}].keys でグループキーを指定するために使ったカラム名を使います。

以下は複数のグループキーを使ったときに `_value.${KEY_NAME}` 構文でそれぞれのグループキーを参照する例です。

実行例:

    select Entries \
      --limit 0 \
      --output_columns _id \
      --drilldowns[tag.n_likes].keys tag,n_likes \
      --drilldowns[tag.n_likes].output_columns _value.tag,_value.n_likes
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ]
    #       ]
    #     ],
    #     {
    #       "tag.n_likes": [
    #         [
    #           4
    #         ],
    #         [
    #           [
    #             "tag",
    #             "ShortText"
    #           ],
    #           [
    #             "n_likes",
    #             "UInt32"
    #           ]
    #         ],
    #         [
    #           "Hello",
    #           5
    #         ],
    #         [
    #           "Groonga",
    #           10
    #         ],
    #         [
    #           "Groonga",
    #           15
    #         ],
    #         [
    #           "Senna",
    #           3
    #         ]
    #       ]
    #     }
    #   ]
    # ]

ちなみに

どうして `_value.${KEY_NAME}` 構文なの？

これは実装よりの情報です。

`_key` はベクターの値です。このベクターの値はすべてのグループキーから成ります。 `drilldowns[${LABEL}].output_columns` で `_key` を参照するとこのベクターの値のバイト列を確認することができます。

drilldowns[${LABEL}].keys に複数のグループキーを指定したとき、各グループの値を参照するために `_value` にグループのレコードが1つだけ保存されています。そのため、各グループキーを参照するために `_value.${KEY_NAME}` 構文を使えます。

一方、 drilldowns[${LABEL}].keys に1つのグループキーしか指定していない場合は、 `_value` にグループのレコードを保存しません。そのため、 `_value.${KEY_NAME}` 構文でグループキーを参照できません。

#### 7.3.54.4.8.3. `drilldowns[${LABEL}].columns[${NAME}].stage`

バージョン 6.0.5 で追加.

どのタイミング（どのステージ）で動的カラムを作るかを指定します。動的カラムを作る場合はこのパラメーターは必須です。

指定可能なステージは以下の通りです。

名前 | 説明
--- | ---
`initial` | 最初に動的カラムを作成します。

以下は動的カラム作成タイミング入りの各ドリルダウンの処理の流れです。できるだけ後のステージを選ぶべきです。

> 1. drilldowns[${LABEL}].keys 、 `drilldowns[${LABEL}].calc_types` 、 `drilldowns[${LABEL}].calc_target` を評価します。

> 2. `initial` ステージの動的カラムを作ります。すべてのドリルダウン結果レコードはこの動的カラムを持ちます。

> 3. `drilldowns[${LABEL}].filter` を評価します。 `initial` ステージで作った動的カラムを使えます。

> 4. `drilldowns[${LABEL}].sort_keys` 、 `drilldowns[${LABEL}].offset` 、 `drilldowns[${LABEL}].limit` を評価します。 `initial` ステージで作った動的カラムを使えます。

> 5. drilldowns[${LABEL}].output_columns を評価します。 `initial` ステージで作った動的カラムを使えます。

以下は `drilldowns[${LABEL}].columns[${NAME}].stage` の使用例です。この例では `initial` ステージで `is_popular` カラムを作っています。作成した `is_popular` カラムは `drilldowns[${LABEL}].filter` と `drilldowns[${LABEL}].output_columns` で使えます。

実行例:

    select Entries \
      --drilldowns[tag].keys tag \
      --drilldowns[tag].columns[is_popular].stage initial \
      --drilldowns[tag].columns[is_popular].type Bool \
      --drilldowns[tag].columns[is_popular].value '_nsubrecs > 1' \
      --drilldowns[tag].filter is_popular \
      --drilldowns[tag].output_columns _key,is_popular,_nsubrecs
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ],
    #     {
    #       "tag": [
    #         [
    #           2
    #         ],
    #         [
    #           [
    #             "_key",
    #             "ShortText"
    #           ],
    #           [
    #             "is_popular",
    #             "Bool"
    #           ],
    #           [
    #             "_nsubrecs",
    #             "Int32"
    #           ]
    #         ],
    #         [
    #           "Groonga",
    #           true,
    #           2
    #         ],
    #         [
    #           "Senna",
    #           true,
    #           2
    #         ]
    #       ]
    #     }
    #   ]
    # ]

バージョン 4.0.8 で追加.

#### 7.3.54.4.8.4. `drilldowns[${LABEL}]` スタイルの出力フォーマット

drilldown と drilldowns[${LABEL}].keys には出力フォーマットに違いがあります。 drilldown は複数のドリルダウン結果を出力するために配列を使います。 drilldowns[${LABEL}].keys は「ラベル」と「ドリルダウン結果」のペアの集まりを使います。

drilldown の出力フォーマットは以下の通りです:

    [
      HEADER,
      [
        SEARCH_RESULT,
        DRILLDOWN_RESULT1,
        DRILLDOWN_RESULT2,
        ...
      ]
    ]

drilldowns[${LABEL}].keys の出力フォーマットは以下の通りです:

    [
      HEADER,
      [
        SEARCH_RESULT,
        {
          "LABEL1": DRILLDOWN_RESULT1,
          "LABEL2": DRILLDOWN_RESULT2,
          ...
        }
      ]
    ]

### 7.3.54.4.9. スライス関連の引数

バージョン 6.0.3 で追加.

このセクションではスライス関連のパラメーターについて説明します。

TODO

スライスのパラメーターは以下の通りです。

名前 | 必須
--- | ---
`--slices[${LABEL}].match_columns` | 省略可能
`--slices[${LABEL}].query` | `--slices[${LABEL}].filter` を指定していないときは必須です。
`--slices[${LABEL}].filter` | `--slices[${LABEL}].query` を指定していないときは必須です。
`--slices[${LABEL}].query_expander` | 省略可能
`--slices[${LABEL}].query_flags` | 省略可能
`--slices[${LABEL}].sort_keys` | 省略可能
`--slices[${LABEL}].output_columns` | 省略可能
`--slices[${LABEL}].offset` | 省略可能
`--slices[${LABEL}].limit` | 省略可能
`--slices[${LABEL}].table` | 省略可能

#### 7.3.54.4.9.1. `slices[${LABEL}].match_columns`

TODO

#### 7.3.54.4.9.2. `slices[${LABEL}].query`

TODO

#### 7.3.54.4.9.3. `slices[${LABEL}].filter`

TODO

#### 7.3.54.4.9.4. `slices[${LABEL}].query_expander`

TODO

#### 7.3.54.4.9.5. `slices[${LABEL}].query_flags`

TODO

#### 7.3.54.4.9.6. `slices[${LABEL}].sort_keys`

TODO

#### 7.3.54.4.9.7. `slices[${LABEL}].output_columns`

TODO

#### 7.3.54.4.9.8. `slices[${LABEL}].offset`

TODO

#### 7.3.54.4.9.9. `slices[${LABEL}].limit`

TODO

#### 7.3.54.4.9.10. `slices[${LABEL}].table`

TODO

### 7.3.54.4.10. キャッシュ関連の引数

#### 7.3.54.4.10.1. `cache`

このクエリーの結果をキャッシュするかどうかを指定します。

このクエリーの結果がキャッシュしてあると、次に同じクエリーを実行するときはキャッシュを使って高速にレスポンスを返すことができます。

これは既存のキャッシュされた結果を使うかどうかを指定するものではありません。

指定可能な値は以下の通りです。

Value | 説明
--- | ---
`no` | このクエリーの出力をキャッシュしない。
`yes` | このクエリーの出力をキャッシュする。デフォルト値。

このクエリーの結果をキャッシュしないようにする例です。

実行例:

    select Entries --cache no
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ],
    #         [
    #           "tag",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5,
    #         "Hello"
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10,
    #         "Groonga"
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15,
    #         "Groonga"
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3,
    #         "Senna"
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3,
    #         "Senna"
    #       ]
    #     ]
    #   ]
    # ]

デフォルト値は `yes` です。

### 7.3.54.4.11. スコアー関連の引数

スコアー関連のパラメーターは `adjuster` だけです。

#### 7.3.54.4.11.1. `adjuster`

1つ以上のスコアー調整式（score adjust expression）を指定します。 `adjuster` は `query` または `filter` と一緒に使います。検索しないリクエストでは `adjuster` は動きません。

`adjuster` を使うと特定のレコードのスコアーを増やすことができます。重要なレコードに高いスコアーをつけるために `adjuster` を使えます。

例えば、 `groonga` タグがついたレコードのスコアーを増やすために `adjuster` を使えます。

以下が構文です:

    --adjuster "SCORE_ADJUST_EXPRESSION1 + SCORE_ADJUST_EXPRESSION2 + ..."

以下が `SCORE_ADJUST_EXPRESSION` の構文です:

    COLUMN @ "KEYWORD" * FACTOR

以下のことに注意してください:

> - `COLUMN` にはインデックスが張っていないといけません。

> - `"KEYWORD"` は文字列でないといけません。

> - `FACTOR` は正の整数でないといけません。

以下は1つだけ `SCORE_ADJUST_EXPRESSION` を使った `adjuster` の使用例です。

実行例:

    select Entries \
      --filter true \
      --adjuster 'content @ "groonga" * 5' \
      --output_columns _key,content,_score
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         6
    #       ],
    #       [
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         1
    #       ],
    #       [
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         1
    #       ],
    #       [
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         1
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドはすべてのレコードにマッチします。それから、 `adjuster` を適用します。このアジャスターは `Entries.content` カラムの中に `"groonga"` を含むレコードのスコアーを5増やします。 `Entries.content` カラムに `"groonga"` が含まれているレコードは1つだけです。 `"Groonga"` というキーのレコードです。このレコードのスコアーは6（ `= 1 + 5` ）になります。

`FACTOR` は省略できます。 `FACTOR` を省略すると、1を指定したとみなします。

`FACTOR` を省略した `adjuster` の使用例です。

実行例:

    select Entries \
      --filter true \
      --adjuster 'content @ "groonga"' \
      --output_columns _key,content,_score
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         2
    #       ],
    #       [
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         1
    #       ],
    #       [
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         1
    #       ],
    #       [
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         1
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドの `adjuster` は `FACTOR` がありません。そのため、係数は1になります。 `Entries.content` カラムに `"groonga"` を含むレコードは1つだけです。キーが `"Groonga"` のレコードです。このレコードのスコアーは2（ `= 1 + 1` ）になります。

複数の `SCORE_ADJUST_EXPRESSION` を使った `adjuster` の使用例です。

実行例:

    select Entries \
      --filter true \
      --adjuster 'content @ "groonga" * 5 + content @ "started" * 3' \
      --output_columns _key,content,_score
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "_score",
    #           "Int32"
    #         ]
    #       ],
    #       [
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         1
    #       ],
    #       [
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         9
    #       ],
    #       [
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         4
    #       ],
    #       [
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         1
    #       ],
    #       [
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         1
    #       ]
    #     ]
    #   ]
    # ]

この `select` コマンドの `adjuster` には2つの `SCORE_ADJUST_EXPRESSION` があります。最終的なスコアーの増分はすこれらの `SCORE_ADJUST_EXPRESSION` のスコアーの合計になります。この `select` コマンドのすべての `SCORE_ADJUST_EXPRESSION` はキーが `"Groonga"` のレコードに適用されます。そのため、このレコードの最終的なスコアーの増分はすべての `SCORE_ADJUST_EXPRESSION` の合計になります。

最初の `SCORE_ADJUST_EXPRESSION` は `content @ "groonga" * 5` です。これは、スコアーを5増やします。

2番目の `SCORE_ADJUST_EXPRESSION` は `content @ "started" * 3` です。これはスコアーを3増やします。

最終的なスコアーの増分は9（ `= 1 + 5 + 3` ）です。

1つの `SCORE_ADJUST_EXPRESSION` は `"KEYWORD"` に対して1つの係数を持ちます。これは、 `"KEYWORD"` を持つすべてのレコードでスコアーの増加分は同じということです。 `"KEYWORD"` を持つそれぞれのレコード毎にスコアーの増加分を変えることができます。これは検索スコアーをチューニングするときに便利です。詳細は 重み付きベクターカラム を参照してください。

## 7.3.54.5. 戻り値

`select` は以下のフォーマットのレスポンスを返します:

    [
      HEADER,
      [
        SEARCH_RESULT,
        DRILLDOWN_RESULT_1,
        DRILLDOWN_RESULT_2,
        ...,
        DRILLDOWN_RESULT_N
      ]
    ]

`select` が失敗すると、 `HEADER` にエラーの詳細が含まれます。

`HEADER` については 出力形式 を参照してください。

0個以上の `DRILLDOWN_RESULT` があります。もし、 `drilldown` も `drilldowns[${LABEL}].keys` も指定していない場合、次のように `DRILLDOWN_RESULT` は出力されません:

    [
      HEADER,
      [
        SEARCH_RESULT
      ]
    ]

`--drilldown "_key, column1, column2"` というように `drilldown` に2つ以上のキーがある場合、複数の `DRILLDOWN_RESULT` が存在します:

    [
      HEADER,
      [
        SEARCH_RESULT,
        DRILLDOWN_RESULT_FOR_KEY,
        DRILLDOWN_RESULT_FOR_COLUMN1,
        DRILLDOWN_RESULT_FOR_COLUMN2
      ]
    ]

もし `drilldowns[${LABEL}].keys` を使っているなら、 `DRILLDOWN_RESULT` が1つだけ存在します:

    [
      HEADER,
      [
        SEARCH_RESULT,
        DRILLDOWN_RESULT_FOR_LABELED_DRILLDOWN
      ]
    ]

`DRILLDOWN_RESULT` のフォーマットは `drilldown` と `drilldowns[${LABEL}].keys` で違います。これについては後述します。

`SEARCH_RESULT` は以下のフォーマットです:

    [
      [N_HITS],
      COLUMNS,
      RECORDS
    ]

このフォーマットの具体例は 簡単な使い方 を見てください。

`N_HITS` は limit を適用する前のマッチしたレコード数です。

`COLUMNS` は output_columns で指定した出力カラムの情報を表しています。これは次のフォーマットになっています:

    [
      [COLUMN_NAME_1, COLUMN_TYPE_1],
      [COLUMN_NAME_2, COLUMN_TYPE_2],
      ...,
      [COLUMN_NAME_N, COLUMN_TYPE_N]
    ]

`COLUMNS` は1つ以上の出力カラムの情報を含んでいます。各出力カラムの情報は次の情報を含んでいます。

> - カラム名（文字列）

> - カラムの型（文字列または `null` ）

カラム名は output_columns で指定された値から抽出しています。

カラムの方はGroongaでの型名または `null` です。カラムがベクターかスカラーかの情報は持っていません。実際のカラムの値が配列かどうかで判断する必要があります。

型の詳細は データ型 を見てください。

`null` になるときはカラムの値の型を決められないときです。たとえば、 `--output_columns "snippet_html(content)"` というように output_columns の中で関数呼び出しを使ったときは `null` になります。

以下は `COLUMNS` の使用例です:

    [
      ["_id",     "UInt32"],
      ["_key",    "ShortText"],
      ["n_likes", "UInt32"],
    ]

`RECORDS` はマッチした各レコードのカラムの値を含んでいます。 `RECORDS` に含まれるレコードは offset と limit で選択されたレコードです。 `RECORDS` は次のフォーマットです:

    [
      [
        RECORD_1_COLUMN_1,
        RECORD_1_COLUMN_2,
        ...,
        RECORD_1_COLUMN_N
      ],
      [
        RECORD_2_COLUMN_1,
        RECORD_2_COLUMN_2,
        ...,
        RECORD_2_COLUMN_N
      ],
      ...
      [
        RECORD_N_COLUMN_1,
        RECORD_N_COLUMN_2,
        ...,
        RECORD_N_COLUMN_N
      ]
    ]

以下は `RECORDS` の例です:

    [
      [
        1,
        "The first post!",
        5
      ],
      [
        2,
        "Groonga",
        10
      ],
      [
        3,
        "Mroonga",
        15
      ]
    ]

`DRILLDOWN_RESULT` のフォーマットは `drilldown` と `drilldowns[${LABEL}].keys` で違います。

`drilldown` は `SEARCH_RESULT` と同じフォーマットです:

    [
      [N_HITS],
      COLUMNS,
      RECORDS
    ]

drilldown で1つ以上のキーを指定すると、 `drilldown` は1つ以上の `DRILLDOWN_RESULT` を出力します。

`drilldowns[${LABEL}].keys` は次のフォーマットを使います。複数の `drilldowns[${LABEL}].keys` は1つのオブジェクト（キーと値のペアの集合）になります:

    {
      "LABEL_1": [
        [N_HITS],
        COLUMNS,
        RECORDS
      ],
      "LABEL_2": [
        [N_HITS],
        COLUMNS,
        RECORDS
      ],
      ...,
      "LABEL_N": [
        [N_HITS],
        COLUMNS,
        RECORDS
      ]
    }

各 `drilldowns[${LABEL}].keys` は次の部分に対応します:

    "LABEL": [
      [N_HITS],
      COLUMNS,
      RECORDS
    ]

以下の値の部分は `SEARCH_RESULT` と同じフォーマットです:

    [
      [N_HITS],
      COLUMNS,
      RECORDS
    ]

`drilldownss[${LABEL}]` スタイルのドリルダウンの出力形式については drilldowns[${LABEL}] スタイルの出力フォーマット も見てください。

## 7.3.54.6. 参考

> - クエリー構文
> - スクリプト構文