Skip to main content
`Ctrl`+`K`

# 7.13.1. クエリー構文

クエリー構文は一般的なWebの検索フォームで検索条件を指定するための構文です。Googleの検索フォームで使われている構文に似ています。例えば、 `word1 word2` は `word1` と `word2` の両方の単語を含んだレコードを検索するという意味です。 `word1 OR word2` は `word1` または `word2` のどちらかの単語を含んだレコードを検索します。

Query syntax consists of 条件式 , 結合式 and 代入式. Normally 代入式 can be ignored. Because 代入式 is disabled in the query option of select. You can use it by specifying `ALLOW_UPDATE` to the query_flags option.

条件式 specifies an condition. 結合式 consists of one or more 条件式, 結合式 or 代入式. 代入式 can assigns a value to a column.

## 7.13.1.1. サンプルデータ

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

実行例:

    table_create Entries TABLE_PAT_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]
    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},
    {"_key":    "Groonga",
     "content": "I started to use Groonga. It's very fast!",
     "n_likes": 10},
    {"_key":    "Mroonga",
     "content": "I also started to use Mroonga. It's also very fast! Really fast!",
     "n_likes": 15},
    {"_key":    "Good-bye Senna",
     "content": "I migrated all Senna system!",
     "n_likes": 3},
    {"_key":    "Good-bye Tritonn",
     "content": "I also migrated all Tritonn system!",
     "n_likes": 3}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 5]

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

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

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

## 7.13.1.2. エスケープ

クエリー構文には特別な文字があります。特別な文字それ自体を使うためには文字の前に `\` をつけてエスケープしなければいけません。例えば、 `"` は特別な文字です。これは `\"` というようにエスケープします。

以下が特別な文字のリストです:

- `[space]` （ `[backslash][space]` とエスケープする。）（ `[space]` をASCIIで言えば0x20の空白文字に置き換えて、 `[backslash]` を `\\` に置き換えてください。）

- `"` （ `\"` とエスケープする。）

- `(` （ `\(` とエスケープする。）

- `)` （ `\)` とエスケープする。）

- `\` （ `\\` とエスケープする。）

`\` （バックスラッシュ）以外はエスケープする代わりにクォートすることもできます。クォート中でバックスラッシュをエスケープするときは `\\` というようにバックスラッシュを使います。

クォート構文は `"..."` です。 `"..."` クォート構文中では `"` を `\"` にエスケープする必要があります。例えば、 `You say "Hello Alice!"` は `"You say \"Hello Alice!\""` とクォートします。

なお、 `'...'` はクエリー構文では使えません。

注釈

注意しなければならない大事な点があります。`\` (バックスラッシュ)はコマンドラインシェルが解釈します。それゆえ例えば `(` それ自体を検索したいならシェルでは二重にエスケープ (`\\(`) しなければなりません。コマンドラインシェルは `\\(` を `\(` と解釈してからGroongaに渡します。Groongaは `\(` を `(` とみなし、`(` 自体をデータベースから検索します。もし意図した検索がGroongaで行えないなら、特別な文字を正しくエスケープしているか確認します。

## 7.13.1.3. 条件式

以下は利用可能な条件式の一覧です。

### 7.13.1.3.1. 全文検索条件

構文は `keyword` です。

`全文検索条件` はデフォルトのマッチカラムに対して全文検索するという条件を指定します。マッチカラムとは全文検索対象のカラムのことです。

全文検索に使うデフォルトのマッチカラムを指定する必要があります。マッチカラムは select の `--match_columns` オプションで指定します。デフォルトのマッチカラムを指定していない場合、この条件式は失敗します。

この条件式は `keyword` で全文検索をします。 `keyword` には空白を含めることはできません。 `search keyword` というように空白を含んでいる場合は、 `search` と `keyword` という2つの全文検索条件を指定したことになります。もし、キーワードに空白を含めたい場合は以下で説明する `フレーズ検索条件` を使ってください。

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

実行例:

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

この式は `content` カラムの値に `fast` という単語を含んでいるレコードにマッチします。

`content` カラムはデフォルトのマッチカラムです。

### 7.13.1.3.2. フレーズ検索条件

構文は `"search keyword"` です。

`フレーズ検索条件` はデフォルトのマッチカラムに対してフレーズ検索するという条件を指定します。

全文検索に使うデフォルトのマッチカラムを指定する必要があります。マッチカラムは select の `--match_columns` オプションで指定します。デフォルトのマッチカラムを指定していない場合、この条件式は失敗します。

この条件式は `search keyword` でフレーズ検索をします。フレーズ検索は `search` と `keyword` がこの順番で隣接して含まれているレコードにマッチします。つまり、 `Put a search keyword in the form` にはマッチしますが、 `Search by the keyword` や `There is a keyword. Search by it!` にはマッチしません。

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

実行例:

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

この式は `content` カラムの値に `I started` というフレーズを含んでいるレコードにマッチします。 `I also started` にはマッチしません。これは `I` と `started` が隣接していないからです。

`content` カラムはデフォルトのマッチカラムです。

### 7.13.1.3.3. 全文検索条件（マッチカラム指定あり）

構文は `column:@keyword` です。

これは `全文検索条件` と似ていますが、デフォルトのマッチカラムは必要ありません。全文検索用のマッチカラムは select の `--match_columns` オプションではなく `column:` で指定します。

この条件式は異なったカラムに対して複数の全文検索をしたい場合に便利です。 `--match_columns` オプションで指定するデフォルトのマッチカラムは複数回指定することができません。2つめのマッチカラムを指定するためにはこの条件式を使う必要があります。

`全文検索条件` と `全文検索条件（マッチカラム指定あり）` の違いは高度なマッチカラムをサポートしているかどうかです。 `全文検索条件` は高度なマッチカラムをサポートしていますが、 `全文検索条件（マッチカラム指定あり）` はサポートしていません。高度なマッチカラムには以下の機能があります:

- 重みをサポートしている。

- 複数のカラムを指定できる。

- マッチカラムとしてインデックスカラムを使える。

これらについては select の `--match_columns` オプションを参照してください。

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

実行例:

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

この式は `content` カラムの値に `fast` という単語を含んでいるレコードにマッチします。

### 7.13.1.3.4. フレーズ検索条件（マッチカラム指定あり）

構文は `column:@"search keyword"` です。

これは `フレーズ検索条件` に似ていますが、デフォルトのマッチカラムは必要ありません。フレーズ検索用のマッチカラムは select の `--match_columns` オプションではなく `column:` で指定します。

`フレーズ検索条件` と `フレーズ検索条件（マッチカラム指定あり）` は `全文検索条件` と `全文検索条件（マッチカラム指定あり）` の関係と似ています。 `フレーズ検索条件` は高度なマッチカラムをサポートしていますが、 `フレーズ検索条件（マッチカラム指定あり）` はサポートしていません。高度なマッチカラムについては `全文検索条件（マッチカラム指定あり）` を参照してください。

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

実行例:

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

この式は `content` カラムの値に `I started` というフレーズを含んでいるレコードにマッチします。 `I also started` にはマッチしません。これは `I` と `started` が隣接していないからです。

### 7.13.1.3.5. 前方一致検索条件

構文は `column:^value` または `value*` です。

この条件式は `value` で前方一致検索をします。前方一致検索は `value` で始まる単語を含むレコードを検索します。

カラムの値を高速に前方一致検索できます。ただし、そのカラムにはインデックスを作成し、そのインデックス用のテーブルをパトリシアトライ（ `TABLE_PAT_KEY` ）またはダブル配列トライ（ `TABLE_DAT_KEY` ）にしなければいけません。あるいは、パトリシアトライテーブルまたはダブル配列テーブルの `_key` も高速に前方一致検索できます。 `_key` にインデックスを作成する必要はありません。

他の種類のテーブルでも前方一致検索を使えますがレコード全件を処理します。レコード数が少ない場合には問題ありませんが、レコード数が多いと時間がかかります。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

    select Entries --query '_key:^Goo'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3
    #       ]
    #     ]
    #   ]
    # ]

この式は `_key` カラムの値が `Goo` で始まる単語を含むレコードにマッチします。この式には `Good-bye Senna` と `Good-bye Tritonn` がマッチします。

### 7.13.1.3.6. 後方一致検索条件

構文は `column:$value` です。

この条件式は `value` で後方一致検索します。後方一致検索は `value` で終わる単語を含むレコードを検索します。

カラムの値を高速に後方一致検索できます。ただし、そのカラムにはインデックスを作成し、そのインデックス用のテーブルを `KEY_WITH_SIS` フラグ付きのパトリシアトライテーブル（ `TABLE_PAT_KEY` ）にしなければいけません。 `KEY_WITH_SIS` フラグ付きのパトリシアトライテーブル（ `TABLE_PAT_KEY` ）の `_key` 擬似カラムの値も高速に後方一致検索できます。 `_key` にはインデックスを作成する必要はありません。 `_key` ベースの高速な後方一致検索よりもカラムベースの高速な後方一致検索を使うことをおすすめします。 `_key` ベースの高速な後方一致検索は自動的に登録された部分文字列も返ってきます。（TODO: 後方一致検索に関するドキュメントを書いてここからリンクを張る。）

注釈

高速な後方一致検索は日本語のひらがななど非ASCII文字にしか使えません。ASCII文字には高速な後方一致検索を使えません。

後方一致検索は他の種類のテーブルもしくはパトリシアトライを `KEY_WITH_SIS` フラグなしで使用しているテーブルに対しても使えますが、レコード全件を処理します。レコード数が少ない場合には問題ありませんが、レコード数が多いと時間がかかります。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

簡単な例です。ASCII文字ではない文字である日本語のひらがなに対して高速な後方一致検索をしています。

実行例:

    table_create Titles TABLE_NO_KEY
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create Titles content COLUMN_SCALAR ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    table_create SuffixSearchTerms TABLE_PAT_KEY|KEY_WITH_SIS ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create SuffixSearchTerms index COLUMN_INDEX Titles content
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table Titles
    [
    {"content": "ぐるんが"},
    {"content": "むるんが"},
    {"content": "せな"},
    {"content": "とりとん"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 4]
    select Titles --query 'content:$んが'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         2,
    #         "むるんが"
    #       ],
    #       [
    #         1,
    #         "ぐるんが"
    #       ]
    #     ]
    #   ]
    # ]

この式は `content` カラムの値が `んが` で終わるレコードにマッチします。この場合は `ぐるんが` と `むるんが` にマッチします。

### 7.13.1.3.7. 近傍検索条件

構文は `*N"トークン1 トークン2 ..."` です。

この条件式は `トークン1` と `トークン2` と `...` で近傍検索をします。近傍検索はすべての指定したトークンが最大でも10トークン以内に存在するレコードを検索します。たとえば、 `*N"a b c"` は `a 1 2 3 4 5 b 6 7 8 9 10 c` にマッチしますが `a 1 2 3 4 5 b 6 7 8 9 10 11 c` にはマッチしません。

実行例:

    table_create NearTokens TABLE_NO_KEY
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create NearTokens content COLUMN_SCALAR ShortText
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    table_create NearTokenTerms TABLE_PAT_KEY ShortText \
      --default_tokenizer TokenNgram \
      --normalizer NormalizerNFKC130
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    column_create NearTokenTerms index COLUMN_INDEX|WITH_POSITION \
      NearTokens content
    # [[0, 1337566253.89858, 0.000355720520019531], true]
    load --table NearTokens
    [
    {"content": "a 1 2 3 4 5 b 6 7 8 9 10 c"},
    {"content": "a 1 2 3 4 5 b 6 7 8 9 10 11 c"},
    {"content": "a 1 2 3 4 5 b 6 7 8 9 10 11 12 c"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 3]
    select NearTokens --match_columns content --query '*N"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ]
    #     ]
    #   ]
    # ]

近傍検索に使うインデックスカラムには `WITH_POSITION` を指定しなければいけないことに注意してください。もし `WITH_POSITION` を指定しないと近傍検索で距離を正しく数えられません。

`*N` のあとに数値を指定すると指定されたトークン群の最大距離（デフォルトは `10` ）をカスタマイズできます。以下は指定されたトークン群の最大距離を `2` にする例です。:

    *N2"..."

以下は指定されたトークン群の最大距離をカスタマイズする例です。

実行例:

    select NearTokens --match_columns content --query '*N11"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ]
    #     ]
    #   ]
    # ]

正確に言うと、近傍検索の条件にトークンではなく単語を指定することもできます。なぜなら指定されたテキストは近傍検索前にトークナイズされるからです。1つの単語は1つ以上のトークンになります。単語を指定すると期待した通りに動かないかもしれません。たとえば、 `*N"a1b2c3d"` は `a 1 b 2 c 3 d` にも `a b c d 1 2 3` にもマッチします。

実行例:

    load --table NearTokens
    [
    {"content": "groonga mroonga rroonga pgroonga"},
    {"content": "groonga rroonga pgroonga mroonga"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 2]
    select NearTokens \
      --match_columns content \
      --query '*NP"\\\"groonga mroonga\\\" pgroonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         6,
    #         "groonga mroonga rroonga pgroonga"
    #       ]
    #     ]
    #   ]
    # ]

なぜなら `*N"a1b2c3d"` は `*N"a 1 b 2 c 3 d"` と等しいからです。

単語を指定したい場合は 近傍フレーズ検索条件 を使ってください。

バージョン 12.0.1 で追加: 各トークン間の最大距離。

各トークンの最大距離を指定することもできます。デフォルトでは制限はありません。これは全体の最大距離が満たされていれば各トークン間の距離はどれだけ開いていてもよいということです。

以下は最初のトークン間の最大距離として `2` 、2番目のトークン間の最大距離として `4` を使う例です。:

    *N10,2|4"a b c"

`10` は最大距離です。

各トークン間の最大距離は `|` で区切ります。

これは `a x b x x x c` にマッチします。しかし、`a x x b c` や `a b x x x x c` などにはマッチしません。なぜなら、前者は最初のトークン間の距離が `3` で `2` より大きいからです。後者は2番目のトークン間の距離が `5` で `4` より大きいです。

以下はトークン間の最大距離をカスタマイズする例です。

実行例:

    select NearTokens --match_columns content --query '*N11,5|5"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]
    select NearTokens --match_columns content --query '*N11,5|6"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]

1つ以上のトークン間の最大距離の指定を省略することができます。省略されたトークン間の最大距離は `-1` として処理されます。これは `*N11,5` と `*N11,5|-1` は同じだということです。 `-1` は最大距離に制限がないという意味です。

以下は1つのトークン間の最大距離を省略する例です。

実行例:

    select NearTokens --match_columns content --query '*N11,5"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]
    select NearTokens --match_columns content --query '*N11,5|-1"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]

余分にトークン間の最大距離を指定することもできます。この場合は単に余分な指定が無視されます。

実行例:

    select NearTokens --match_columns content --query '*N11,5|5|1|1|1"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]
    select NearTokens --match_columns content --query '*N11,5|5"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]

### 7.13.1.3.8. 近傍フレーズ検索条件

構文は `*NP"phrase1 phrase2 ..."` です。

この条件式は `フレーズ1` と `フレーズ2` と `...` で近傍フレーズ検索をします。近傍フレーズ検索はすべてのフレーズが含まれていてかつすべてのフレーズが最大でも10トークン以内にあるレコードを検索します。たとえば、`*NP"a1b2c3d"` は `a 1 b 2 c 3 d` にマッチしますが `a b c d 1 2 3` にはマッチしません。なぜなら後者は順序が違うからです。

実行例:

    select NearTokens --match_columns content --query '*NP"a1b2c3d"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ]
    #     ]
    #   ]
    # ]

`*NP"\"groonga mroonga\" pgroonga"` というようにクォートすることでスペースを含んだフレーズを使うことができます。コマンド構文では `*NP"\\\"groonga mroonga\\\" pgroonga"` というように `\"` をエスケープしないといけないことに注意してください。このクエリーは `groonga mroonga pgroonga` にマッチしますが、 `groonga pgroonga mroonga` にはマッチしません。なぜなら `mroonga` が `groonga` のすぐ右にないからです。

実行例:

    load --table NearTokens
    [
    {"content": "groonga mroonga rroonga pgroonga"},
    {"content": "groonga rroonga pgroonga mroonga"}
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 2]
    select NearTokens \
      --match_columns content \
      --query '*NP"\\\"groonga mroonga\\\" pgroonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         6,
    #         "groonga mroonga rroonga pgroonga"
    #       ]
    #     ]
    #   ]
    # ]

`*NP` のあとに数値を指定すると指定されたフレーズ群の最大距離（デフォルトは `10` ）をカスタマイズできます。以下は指定されたフレーズ群の最大距離を `2` にする例です。:

    *NP2"..."

以下は指定されたフレーズ群の最大距離をカスタマイズする例です。

実行例:

    select NearTokens --match_columns content --query '*NP1"groonga pgroonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         0
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ]
    #     ]
    #   ]
    # ]

最後のフレーズにだけ距離を追加することができます。つまり、最後から2番目のフレーズと最後のフレーズの間だけより多くの距離を許容できるということです。これは同一文内での近傍フレーズ検索を実装するときに便利です。最後のフレーズとして `。` （文末のフレーズ）を指定し、最後の追加距離として `-1` を指定すると、 `。` の前に他のすべてのフレーズが出現しなければいけません。最後のフレーズには `。$` というように最後に `$` をつけなければいけません。

以下は指定されたフレーズ群の最後の追加距離として `-1` を使う例です。:

    *NP10,-1"a b .$"

以下は指定したフレーズ群の最後の追加距離をカスタマイズする例です。

実行例:

    load --table NearTokens
    [
    {"content": "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."},
    {"content": "x 1 2 y 3 4 . x 1 2 y 3 z 4 5 6 7 ."},
    {"content": "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."},
    ]
    # [[0, 1337566253.89858, 0.000355720520019531], 3]
    select NearTokens --match_columns content --query '*NP2,-1"x y .$"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

最後の追加距離に正の数を指定することもできます。最後の追加距離に正の数を指定した場合、次のすべての条件を満たす必要があります。

1. 最初のフレーズと最後から2番目のフレーズの距離は `最大距離` 以下でなければいけない。

2. 最初のフレーズと最後のフレーズの距離は `最大距離` + `最後の追加距離` 以下でなければいけない。

最後の追加距離に負の数を指定した場合は2番目の条件を満たさなくてもよいです。最後のフレーズが出現するだけでよいです。

以下は最後の追加距離として正の数を指定する例です。

実行例:

    select NearTokens --match_columns content --query '*NP2,4"x y .$"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

バージョン 12.0.1 で追加: 各フレーズ間の最大距離。

近傍検索条件 のように各フレーズ間の最大距離を指定することもできます。

以下は使用例です。

実行例:

    select NearTokens --match_columns content --query '*NP11,0,5|5"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]
    select NearTokens --match_columns content --query '*NP11,0,5|6"a b c"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ]
    #     ]
    #   ]
    # ]

### 7.13.1.3.9. 近傍フレーズ直積検索条件

バージョン 11.1.1 で追加.

構文は `*NPP"(フレーズ1-1 フレーズ1-2 ...) (フレーズ2-1 フレーズ2-2 ...) ..."` です。

この条件式は複数の 近傍フレーズ検索条件 をします。各 近傍フレーズ検索条件 が使うフレーズ群は `{フレーズ1-1, フレーズ1-2, ...}` と `{フレーズ2-1, フレーズ2-2, ...}` と `...` の直積として計算します。たとえば、 `*NPP"(a b c) (d e)"` は以下のフレーズ群のリストで近傍フレーズ検索をします。

- `a d`

- `a e`

- `b d`

- `b e`

- `c d`

- `c e`

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

実行例:

    select NearTokens --match_columns content --query '*NPP"(a x) (b y)"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         8
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ],
    #       [
    #         3,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 12 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         9,
    #         "x 1 2 y 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

最大距離や `$` による最後のフレーズ指定や最後の追加距離など 近傍フレーズ検索条件 のすべての機能を使うことができます。

実行例:

    select NearTokens --match_columns content --query '*NPP2,-1"(a x) (b c y) (d$ .$)"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         4
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

バージョン 12.0.1 で追加: 各フレーズ間の最大距離。

近傍検索条件 のように各フレーズ間の最大距離を指定することもできます。

以下は使用例です。

実行例:

    select NearTokens --match_columns content --query '*NPP11,0,5|5"(a x) (b y) (c z)"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         9,
    #         "x 1 2 y 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]
    select NearTokens --match_columns content --query '*NPP11,0,5|6"(a x) (b y) (c z)"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         5
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         9,
    #         "x 1 2 y 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

これは複数の 近傍フレーズ検索条件 よりも効率的です。

### 7.13.1.3.10. 順序付き近傍フレーズ検索条件

バージョン 11.0.9 で追加.

構文は `*ONP"phrase1 phrase2 ..."` です。

この条件式は `フレーズ1` と `フレーズ2` と `...` で順序付き近傍フレーズ検索をします。順序付き近傍フレーズ検索は 近傍フレーズ検索条件 と似ていますが順序付き近傍フレーズ検索はフレーズの順番をチェックします。たとえば、 `*ONP"groonga mroonga pgroonga"` は `groonga mroonga rroonga pgroonga` にマッチしますが `groonga rroonga pgroonga mroonga` にはマッチしません。なぜなら後者は順序が違うからです。

実行例:

    select NearTokens \
      --match_columns content \
      --query '*ONP"groonga mroonga pgroonga"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         6,
    #         "groonga mroonga rroonga pgroonga"
    #       ]
    #     ]
    #   ]
    # ]

最大距離や最後の追加距離といった 近傍フレーズ検索条件 のすべての機能を使えます。しかし、最後のフレーズに `$` を指定する必要はありません。クエリー内の最後のフレーズが最後のフレーズになるからです。

バージョン 12.0.1 で追加: 各フレーズ間の最大距離。

近傍検索条件 のように各フレーズ間の最大距離を指定することもできます。

### 7.13.1.3.11. 順序付き近傍フレーズ直積検索条件

バージョン 11.1.1 で追加.

構文は `*ONPP"(フレーズ1-1 フレーズ1-2 ...) (フレーズ2-1 フレーズ2-2 ...) ..."` です。

この条件式は順序付き近傍フレーズ直積検索をします。順序付き近傍フレーズ直積検索は 近傍フレーズ直積検索条件 と似ていますが、順序付き近傍フレーズ直積検索は 順序付き近傍フレーズ検索条件 のようにフレーズの順序をチェックします。たとえば、 `*ONPP"(a b c) (d e)"` は `a 1 d` にマッチしますが、 `d 1 a` にはマッチしません。なぜなら後者は順序が違うからです。

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

実行例:

    select NearTokens \
      --match_columns content \
      --query '*ONPP"(a x) (b y)"'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         8
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "content",
    #           "ShortText"
    #         ]
    #       ],
    #       [
    #         1,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 c"
    #       ],
    #       [
    #         2,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 c"
    #       ],
    #       [
    #         3,
    #         "a 1 2 3 4 5 b 6 7 8 9 10 11 12 c"
    #       ],
    #       [
    #         4,
    #         "a 1 b 2 c 3 d"
    #       ],
    #       [
    #         5,
    #         "a b c d 1 2 3"
    #       ],
    #       [
    #         8,
    #         "x 1 y 2 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         9,
    #         "x 1 2 y 3 4 . x 1 2 y 3 z 4 5 6 7 ."
    #       ],
    #       [
    #         10,
    #         "x 1 2 3 y 4 . x 1 y 2 z 3 4 5 6 7 ."
    #       ]
    #     ]
    #   ]
    # ]

最大距離や最後の追加距離といった 近傍フレーズ検索条件 のすべての機能を使えます。しかし、最後のフレーズに `$` を指定する必要はありません。クエリー内の最後のフレーズが最後のフレーズになるからです。

バージョン 12.0.1 で追加: 各フレーズ間の最大距離。

近傍検索条件 のように各フレーズ間の最大距離を指定することもできます。

### 7.13.1.3.12. 類似文書検索条件

TODO

### 7.13.1.3.13. 等価条件

構文は `column:value` です。

`column` の値が `value` と等しいレコードにマッチします。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

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

この式は `_key` カラムの値が `Groonga` のレコードにマッチします。

### 7.13.1.3.14. 不等価条件

構文は `column:!value` です。

`column` の値が `value` と等しくないレコードにマッチします。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

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

この式は `_key` カラムの値が `Groonga` ではないレコードにマッチします。

### 7.13.1.3.15. 小なり条件

構文は `column:<value` です。

`column` の値が `value` 未満のレコードにマッチします。

`column` の型が `Int32` などの数値型の場合、 `column` の値と `value` は数値として比較します。もし、 `column` の型が `ShortText` のような文字列型の場合は `column` の値と `value` はビット列として比較します。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

    select Entries --query n_likes:<10
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3
    #       ],
    #       [
    #         5,
    #         "Good-bye Tritonn",
    #         "I also migrated all Tritonn system!",
    #         3
    #       ],
    #       [
    #         1,
    #         "The first post!",
    #         "Welcome! This is my first post!",
    #         5
    #       ]
    #     ]
    #   ]
    # ]

この式は `n_likes` カラムの値が `10` より小さいレコードにマッチします。

### 7.13.1.3.16. 大なり条件

構文は `column:>value` です。

`column` の値が `value` より大きいレコードにマッチします。

`column` の型が `Int32` などの数値型の場合、 `column` の値と `value` は数値として比較します。もし、 `column` の型が `ShortText` のような文字列型の場合は `column` の値と `value` はビット列として比較します。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

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

この式は `n_likes` カラムの値が `10` より大きいレコードにマッチします。

### 7.13.1.3.17. 以下条件

構文は `column:<=value` です。

`column` の値が `value` 以下のレコードにマッチします。

`column` の型が `Int32` などの数値型の場合、 `column` の値と `value` は数値として比較します。もし、 `column` の型が `ShortText` のような文字列型の場合は `column` の値と `value` はビット列として比較します。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

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

この式は `n_likes` カラムの値が `10` 以下のレコードにマッチします。

### 7.13.1.3.18. 以上条件

構文は `column:>=value` です。

`column` の値が `value` 以上のレコードにマッチします。

`column` の型が `Int32` などの数値型の場合、 `column` の値と `value` は数値として比較します。もし、 `column` の型が `ShortText` のような文字列型の場合は `column` の値と `value` はビット列として比較します。

`全文検索条件` や `フレーズ検索条件` と異なり、デフォルトのマッチカラムは必要ありません。

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

実行例:

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

この式は `n_likes` カラムの値が `10` 以上のレコードにマッチします。

### 7.13.1.3.19. 正規表現条件

バージョン 5.0.1 で追加.

構文は `column:~pattern` です。

`column` の値が `pattern` にマッチするレコードにマッチします。 `pattern` は正しい 正規表現 でなければいけません。

以下の例はパターンとして `.roonga` を使っています。このパターンは `Groonga` 、 `Mroonga` といった文字列にマッチします。

実行例:

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

多くの場合、各レコードに対して順に正規表現を評価します。そのため、多くのレコードがある場合は遅くなるかもしれません。

いくつかのケースでは、Groongaはインデックスを使って正規表現を評価します。これはとても高速です。詳細は 正規表現 を参照してください。

## 7.13.1.4. 結合式

以下は利用可能な結合式のリストです。

### 7.13.1.4.1. 論理和

構文は `a OR b` です。

`a` と `b` は条件式または結合式または代入式です。

`a` と `b` のうち少なくともひとつの式がマッチすれば `a OR b` はマッチします。

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

実行例:

    select Entries --query 'n_likes:>10 OR content:@senna'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         2
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3
    #       ]
    #     ]
    #   ]
    # ]

この式は `n_likes` カラムの値が `10` より大きいか `content` カラムの値に `senna` という単語を含んでいるレコードにマッチします。

### 7.13.1.4.2. 論理積

構文は `a + b` です。あるいは単に `a b` と書くこともできます。

`a` と `b` は条件式または結合式または代入式です。

`a` と `b` の両方にマッチすれば `a + b` はマッチします。

`+a` というように最初の式に `+` を指定することもできます。この場合は `+` は単に無視されます。

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

実行例:

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

この式は `n_likes` カラムの値が `10` 以上で `content` カラムの値に `groonga` という単語を含むレコードにマッチします。

### 7.13.1.4.3. 論理差

構文は `a - b` です。

`a` と `b` は条件式または結合式または代入式です。

`a` にマッチして `b` にマッチしなければ、 `a - b` はマッチします。

`-a` というように最初の式に `-` を指定することはできません。この場合は構文エラーになります。

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

実行例:

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

この式は `n_likes` カラムの値が `10` 以上で `content` カラムの値に `groonga` という単語を含まないレコードにマッチします。

### 7.13.1.4.4. グループ化

構文は `(...)` です。 `...` は空白区切りの式のリストです。

`(...)` は1つ以上の式をグループ化します。グループ化された式は1つの式として処理されます。 `a b OR c` は `a` と `b` の両方がマッチするか、 `c` がマッチすれば式全体がマッチする、という意味になります。 `a (b OR c)` は `a` がマッチして `b` と `c` はどちらか一方がマッチすれば式全体がマッチする、という意味になります。

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

実行例:

    select Entries --query 'n_likes:<5 content:@senna OR content:@fast'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         3
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3
    #       ],
    #       [
    #         2,
    #         "Groonga",
    #         "I started to use Groonga. It's very fast!",
    #         10
    #       ],
    #       [
    #         3,
    #         "Mroonga",
    #         "I also started to use Mroonga. It's also very fast! Really fast!",
    #         15
    #       ]
    #     ]
    #   ]
    # ]
    select Entries --query 'n_likes:<5 (content:@senna OR content:@fast)'
    # [
    #   [
    #     0,
    #     1337566253.89858,
    #     0.000355720520019531
    #   ],
    #   [
    #     [
    #       [
    #         1
    #       ],
    #       [
    #         [
    #           "_id",
    #           "UInt32"
    #         ],
    #         [
    #           "_key",
    #           "ShortText"
    #         ],
    #         [
    #           "content",
    #           "Text"
    #         ],
    #         [
    #           "n_likes",
    #           "UInt32"
    #         ]
    #       ],
    #       [
    #         4,
    #         "Good-bye Senna",
    #         "I migrated all Senna system!",
    #         3
    #       ]
    #     ]
    #   ]
    # ]

最初の式はグループ化していません。この式は `n_likes:<5` と `content:@senna` の両方がマッチするか `content:@fast` がマッチするレコードにマッチします。

2番目の式はグループ化しています。この式は `n_likes:<5` にマッチして、 `content:@senna` と `content:@fast` は少なくともどちらか一方にマッチするレコードにマッチします。

## 7.13.1.5. 代入式

このセクションは高度なユーザー向けです。それは、代入式は select の `--query` オプションではデフォルトでは無効になっているからです。代入式を有効にするには `--query_flags` オプションに `ALLOW_COLUMN|ALLOW_UPDATE` を指定してください。

クエリー構文における代入式にはいくつか制限があります。代入にはクエリー構文の代りに スクリプト構文 を使ってください。

代入式の構文は1つだけです。 `column:=value` となります。

`value` は `column` に代入されます。 `value` は常にクエリー構文では文字列として扱われます。 `value` は `column` の型へと自動的にキャストされます。 キャストにはいくつか制限があります。例えば `true` や `false` といった真偽値のリテラルを `Bool` 型のカラムに使用することができません。 `false` については空文字列を使う必要がありますが、クエリー構文は `column:=` 構文をサポートしていません。

キャストについては Cast を参照してください。