基本演算子

Zilliz Cloud は、エンティティをフィルタリングするための比較、範囲、算術、論理、および NULL 演算子を提供します。各演算子は特定のフィールド型をサポートします。

Notes

フィルタ式の左辺のリテラルには、以下の例で使用されている status や color などのコレクションフィールド名、または filter = 'struct[0][subfield] > 10' のように、特定の要素インデックスにある StructArray サブフィールドの名前を指定できます。

StructArray フィールドでのスカラーフィルタリングの詳細については、StructArray 演算子を参照してください。

比較演算子

比較演算子は、等価性、非等価性、または大小に基づいてデータをフィルタリングするために使用します。数値フィールドとテキストフィールドに適用されます。

サポートされる比較演算子：

==（等しい）
!=（等しくない）
>（より大きい）
<（より小さい）
>=（以上）
<=（以下）

例 1：等しい（`==`）によるフィルタリング

status という名前のフィールドがあり、status が "active" であるすべてのエンティティを検索するとします。等価演算子 == を使用できます：

python
filter = 'status == "active"'

java

String filter = "status == \"active\"";

go
filter := "status == \"active\""

rust
let filter = "status == \"active\"";

c++

std::string filter = "status == \"active\"";

javascript
const filter = 'status == "active"';

bash

filter='status == "active"'

例 2：等しくない（`!=`）によるフィルタリング

status が "inactive" でないエンティティを検索するには：

python
filter = 'status != "inactive"'

java

String filter = "status != \"inactive\"";

go
filter := "status != \"inactive\""

rust
let filter = "status != \"inactive\"";

c++

std::string filter = "status != \"inactive\"";

javascript
const filter = 'status != "inactive"';

bash

filter='status != "inactive"'

例 3：より大きい（`>`）によるフィルタリング

age が 30 より大きいすべてのエンティティを検索する場合は、次のようにします：

python
filter = 'age > 30'

java

String filter = "age > 30";

go
filter := "age > 30"

rust
let filter = "age > 30";

c++

std::string filter = "age > 30";

javascript
const filter = 'age > 30';

bash

filter='age > 30'

例 4：より小さいによるフィルタリング

price が 100 より小さいエンティティを検索するには：

python
filter = 'price < 100'

java

String filter = "price < 100";

go
filter := "price < 100"

rust
let filter = "price < 100";

c++

std::string filter = "price < 100";

javascript
const filter = 'price < 100';

bash

filter='price < 100'

例 5：以上（`>=`）によるフィルタリング

rating が 4 以上のすべてのエンティティを検索する場合は、次のようにします：

python
filter = 'rating >= 4'

java

String filter = "rating >= 4";

go
filter := "rating >= 4"

rust
let filter = "rating >= 4";

c++

std::string filter = "rating >= 4";

javascript
const filter = 'rating >= 4';

bash

filter='rating >= 4'

例 6：以下によるフィルタリング

discount が 10% 以下のエンティティを検索するには：

python
filter = 'discount <= 10'

java

String filter = "discount <= 10";

go
filter := "discount <= 10"

rust
let filter = "discount <= 10";

c++

std::string filter = "discount <= 10";

javascript
const filter = 'discount <= 10';

bash

filter='discount <= 10'

範囲演算子

範囲演算子は、特定の値の集合に基づいてデータをフィルタリングするのに役立ちます。Zilliz Cloud は、集合のメンバーシップチェック用に IN をサポートしています。

color が "red"、"green"、"blue" のいずれかであるすべてのエンティティを検索するには：

python
filter = 'color in ["red", "green", "blue"]'

java

String filter = "color in [\"red\", \"green\", \"blue\"]";

go
filter := "color in [\"red\", \"green\", \"blue\"]"

rust
let filter = "color in [\"red\", \"green\", \"blue\"]";

c++

std::string filter = "color in [\"red\", \"green\", \"blue\"]";

javascript
const filter = 'color in ["red", "green", "blue"]';

bash

filter='color in ["red", "green", "blue"]'

これは、値のリストに含まれているかどうかを確認する場合に便利です。

パターンマッチ演算子

パターンマッチ演算子は、ワイルドカードパターンまたは正規表現に基づいて文字列値をフィルタリングするのに役立ちます。

LIKE：文字列値に対する単純なワイルドカードパターンのマッチングに使用します。たとえば、name LIKE "Prod%" は Prod で始まる値にマッチします。
=~：文字列値を RE2 正規表現でマッチングするために使用します。たとえば、code =~ "E[0-9]{4}" は E1001 などのエラーコードを含む値にマッチします。
!~：RE2 正規表現にマッチする文字列値を除外するために使用します。これは NOT (field =~ "pattern") と同等です。

name が Prod で始まるエンティティを検索するには：

python
filter = 'name LIKE "Prod%"'

java

String filter = "name LIKE \"Prod%\"";

go
filter := "name LIKE \"Prod%\""

rust
let filter = "name LIKE \"Prod%\"";

c++

std::string filter = "name LIKE \"Prod%\"";

javascript
const filter = 'name LIKE "Prod%"';

bash

filter='name LIKE "Prod%"'

code に E1001 などのエラーコードが含まれるエンティティを検索するには：

python
filter = 'code =~ "E[0-9]{4}"'

java

String filter = "code =~ \"E[0-9]{4}\"";

go
filter := "code =~ \"E[0-9]{4}\""

rust
let filter = "code =~ \"E[0-9]{4}\"";

c++

std::string filter = "code =~ \"E[0-9]{4}\"";

javascript
const filter = 'code =~ "E[0-9]{4}"';

bash

filter='code =~ "E[0-9]{4}"'

message が DEBUG で始まるエンティティを除外するには：

python
filter = 'message !~ "^DEBUG"'

java

String filter = "message !~ \"^DEBUG\"";

go
filter := "message !~ \"^DEBUG\""

rust
let filter = "message !~ \"^DEBUG\"";

c++

std::string filter = "message !~ \"^DEBUG\"";

javascript
const filter = 'message !~ "^DEBUG"';

bash

filter='message !~ "^DEBUG"'

LIKE と正規表現の選択、サポートされるフィールド型、正規表現の構文、エスケープ規則、パフォーマンスの詳細については、パターンマッチングを参照してください。Zilliz Cloud では、VARCHAR フィールドまたは JSON 文字列パスに NGRAM インデックスを構築して、対象となるパターンマッチフィルターを高速化することもできます。詳細については、NGRAM を参照してください。

算術演算子

算術演算子を使用すると、数値フィールドを含む計算に基づいて条件を作成できます。

サポートされる算術演算子：

+（加算）
-（減算）
*（乗算）
/（除算）
%（剰余）
**（べき乗）

例 1：剰余（`%`）の使用

id が偶数（つまり 2 で割り切れる）であるエンティティを検索するには：

python
filter = 'id % 2 == 0'

java

String filter = "id % 2 == 0";

go
filter := "id % 2 == 0"

rust
let filter = "id % 2 == 0";

c++

std::string filter = "id % 2 == 0";

javascript
const filter = 'id % 2 == 0';

bash

filter='id % 2 == 0'

例 2：べき乗（`**`）の使用

price を 2 乗した値が 1000 より大きいエンティティを検索するには：

python
filter = 'price ** 2 > 1000'

java

String filter = "price ** 2 > 1000";

go
filter := "price ** 2 > 1000"

rust
let filter = "price ** 2 > 1000";

c++

std::string filter = "price ** 2 > 1000";

javascript
const filter = 'price ** 2 > 1000';

bash

filter='price ** 2 > 1000'

ビット演算子

ビット演算子は、整数フィールドがパーミッション、機能フラグ、ステータスビットなどの複数のフラグをエンコードしている場合に役立ちます。これらの演算子をフィルタ式で使用すると、整数値の個々のビットをチェック、結合、または比較できます。

スカラーフィールドの場合、ビット演算子は INT8、INT16、INT32、INT64 などの整数フィールド型に適用されます。

サポートされるビット演算子

演算子	名前	一般的な用途
`&`	ビット単位の AND	特定のビットがセットされているかを確認します。
`\|`	ビット単位の OR	比較の前にビットを結合します。
`^`	ビット単位の XOR	2 つの値間のビットの差異を比較します。

例：パーミッションビットによるフィルタリング

permissions という名前の整数フィールドがあり、整数の各ビットがパーミッションフラグを表しているとします：

パーミッションフラグ	ビット値
`READ`	`1`
`WRITE`	`2`
`SHARE`	`4`
`ADMIN`	`8`

たとえば、permissions = 5 は、5 = 1 + 4 であるため、READ ビットと SHARE ビットがセットされていることを意味します。

SHARE ビットがセットされているエンティティを検索するには、ビット単位の AND（&）を使用します：

python
filter = "(permissions & 4) == 4"

java

String filter = "(permissions & 4) == 4";

go
filter := "(permissions & 4) == 4"

rust
let filter = "(permissions & 4) == 4";

c++

std::string filter = "(permissions & 4) == 4";

javascript
const filter = '(permissions & 4) == 4';

bash

filter='(permissions & 4) == 4'

WRITE ビットをセットすると READ + WRITE + SHARE のパーミッションセットになるエンティティを検索するには、ビット単位の OR（|）を使用します：

python
filter = "(permissions | 2) == 7"

java

String filter = "(permissions | 2) == 7";

go
filter := "(permissions | 2) == 7"

rust
let filter = "(permissions | 2) == 7";

c++

std::string filter = "(permissions | 2) == 7";

javascript
const filter = '(permissions | 2) == 7';

bash

filter='(permissions | 2) == 7'

パーミッションビットが READ + WRITE + SHARE と WRITE ビットだけ異なるエンティティを検索するには、ビット単位の XOR（^）を使用します：

python
filter = "(permissions ^ 7) == 2"

java

String filter = "(permissions ^ 7) == 2";

go
filter := "(permissions ^ 7) == 2"

rust
let filter = "(permissions ^ 7) == 2";

c++

std::string filter = "(permissions ^ 7) == 2";

javascript
const filter = '(permissions ^ 7) == 2';

bash

filter='(permissions ^ 7) == 2'

注記：結果を比較する前に、(permissions & 4) == 4 のように、ビット演算を必ず括弧で囲んでください。

論理演算子

論理演算子は、複数の条件をより複雑なフィルタ式に結合するために使用します。これには AND、OR、NOT が含まれます。

サポートされる論理演算子：

AND：すべてが true でなければならない複数の条件を結合します。
OR：少なくとも 1 つが true でなければならない条件を結合します。
NOT：条件を否定します。

例 1：`AND` を使用した条件の結合

price が 100 より大きく、かつ stock が 50 より大きいすべての製品を検索するには：

python
filter = 'price > 100 AND stock > 50'

java

String filter = "price > 100 AND stock > 50";

go
filter := "price > 100 AND stock > 50"

rust
let filter = "price > 100 AND stock > 50";

c++

std::string filter = "price > 100 AND stock > 50";

javascript
const filter = 'price > 100 AND stock > 50';

bash

filter='price > 100 AND stock > 50'

例 2：`OR` を使用した条件の結合

color が "red" または "blue" のいずれかであるすべての製品を検索するには：

python
filter = 'color == "red" OR color == "blue"'

java

String filter = "color == \"red\" OR color == \"blue\"";

go
filter := "color == \"red\" OR color == \"blue\""

rust
let filter = "color == \"red\" OR color == \"blue\"";

c++

std::string filter = "color == \"red\" OR color == \"blue\"";

javascript
const filter = 'color == "red" OR color == "blue"';

bash

filter='color == "red" OR color == "blue"'

例 3：`NOT` を使用した条件の除外

color が "green" でないすべての製品を検索するには：

python
filter = 'NOT color == "green"'

java

String filter = "NOT color == \"green\"";

go
filter := "NOT color == \"green\""

rust
let filter = "NOT color == \"green\"";

c++

std::string filter = "NOT color == \"green\"";

javascript
const filter = 'NOT color == "green"';

bash

filter='NOT color == "green"'

IS NULL 演算子と IS NOT NULL 演算子

IS NULL と IS NOT NULL は、フィールド値が欠落しているエンティティまたは利用可能なエンティティを検索するために使用します。たとえば、カテゴリを持たない製品や、埋め込みが検索可能な状態にあるエンティティを検索できます。どちらの演算子も、サポートされているスカラーフィールドとベクトルフィールドに対して同じ意味で機能します：

演算子	一致する対象
`<field> IS NULL`	指定されたフィールドが NULL 値を持つエンティティ
`<field> IS NOT NULL`	指定されたフィールドが非 NULL 値を持つエンティティ

サポートされるスカラーフィールドには、Boolean、数値、VARCHAR、JSON、ARRAY フィールドが含まれます。これらの演算子は TEXT フィールドをサポートしていません。

Milvus 3.0.3 以降では、これらの演算子は通常のベクトルフィールドもサポートします：FLOAT_VECTOR、BINARY_VECTOR、FLOAT16_VECTOR、BFLOAT16_VECTOR、SPARSE_FLOAT_VECTOR、INT8_VECTOR。

これらの演算子では大文字と小文字が区別されません：IS NULL と is null は同等であり、IS NOT NULL と is not null も同様です。

例：値が欠落しているエンティティまたは利用可能な値を持つエンティティの検索

products という名前のコレクションがインデックス化され、ロードされているとします。このコレクションには、id という名前の INT64 プライマリキー、category という名前の Null 許容 VARCHAR フィールド、および embedding という名前の Null 許容の 3 次元 FLOAT_VECTOR フィールドがあります。すでに次のエンティティが含まれています：

`id`	`category`	`embedding`
`1`	`"book"`	`[0.1, 0.2, 0.3]`
`2`	NULL	`[0.4, 0.5, 0.6]`
`3`	`"book"`	NULL

コレクションの作成とデータの挿入は省略します。これらの手順については、Null 許容フィールドを参照してください。

まだ埋め込みが必要なエンティティを検索するには、embedding IS NULL でクエリを実行します。サーバーに合わせて接続設定を調整してください。

python
from pymilvus import MilvusClient

client = MilvusClient(uri="YOUR_CLUSTER_ENDPOINT")

results = client.query(
    collection_name="products",
    filter="category IS NULL",
    output_fields=["id"],
    limit=10,
)
print(sorted(entity["id"] for entity in results))
# Expected: [2]

java
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.QueryReq;
import io.milvus.v2.service.vector.response.QueryResp;
import java.util.Collections;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("YOUR_CLUSTER_ENDPOINT")
        .build());

QueryReq queryReq = QueryReq.builder()
        .collectionName("products")
        .filter("category IS NULL")
        .outputFields(Collections.singletonList("id"))
        .limit(10)
        .build();
QueryResp queryResp = client.query(queryReq);
System.out.println(queryResp.getQueryResults());

go
ctx := context.Background()
cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "YOUR_CLUSTER_ENDPOINT",
    APIKey:  "YOUR_CLUSTER_TOKEN",
})
if err != nil {
    log.Fatal("failed to connect to milvus server: ", err.Error())
}
defer cli.Close(ctx)

rs, err := cli.Query(ctx, milvusclient.NewQueryOption("products").
    WithFilter("category IS NULL").
    WithOutputFields("id").
    WithLimit(10))
if err != nil {
    log.Fatal("failed to query: ", err.Error())
}
ids := rs.GetColumn("id")
var result []int64
for i := 0; i < ids.Len(); i++ {
    v, _ := ids.GetAsInt64(i)
    result = append(result, v)
}
fmt.Println(result)

rust
use milvus::v2::prelude::*;

#[tokio::main]
async fn main() -> Result<()> {
    let client = ClientV2::new(
        &ConnectConfig::new().uri("YOUR_CLUSTER_ENDPOINT").token("YOUR_CLUSTER_TOKEN"),
    )
    .await?;

    let request = QueryRequest::builder()
        .collection_name("products")
        .filter("category IS NULL")
        .output_fields(["id"])
        .limit(10)
        .build()?;
    let response = client.query(request).await?;
    for row in response.results().rows()? {
        println!("{:?}", row.get_i64("id")?);
    }
    Ok(())
}

c++
#include <iostream>
#include <string>
#include "milvus/MilvusClientV2.h"

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"YOUR_CLUSTER_ENDPOINT"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

auto request = milvus::QueryRequest()
                   .WithCollectionName("products")
                   .WithFilter("category IS NULL")
                   .AddOutputField("id")
                   .WithLimit(10);

milvus::QueryResponse response;
status = client->Query(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

javascript
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({ address: "YOUR_CLUSTER_ENDPOINT", token: "YOUR_CLUSTER_TOKEN" });

const results = await client.query({
  collection_name: "products",
  filter: "category IS NULL",
  output_fields: ["id"],
  limit: 10,
});
console.log(results);

bash
curl -X 'POST' \
  'YOUR_CLUSTER_ENDPOINT/v2/vectordb/entities/query' \
  -H 'accept: application/json' \
  -H 'Authorization: Bearer YOUR_CLUSTER_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "collectionName": "products",
    "filter": "category IS NULL",
    "outputFields": ["id"],
    "limit": 10
  }'

同じクエリ内の filter を置き換えて、いずれかのフィールドをチェックしたり、条件を組み合わせたりします：

フィルタ式	一致する ID	目的
`category IS NULL`	`2`	カテゴリを持たないエンティティを検索します。
`category IS NOT NULL`	`1`, `3`	カテゴリを持つエンティティを検索します。
`embedding IS NULL`	`3`	埋め込みを持たないエンティティを検索します。
`embedding IS NOT NULL`	`1`, `2`	埋め込みを持つエンティティを検索します。
`category IS NOT NULL AND embedding IS NOT NULL`	`1`	両方の値を持つエンティティを検索します。

フィールド値の扱い

演算子は保存されているフィールド値をチェックします。デフォルト値のない Null 許容フィールドでは、挿入時にフィールドを省略するか、明示的に NULL に設定すると、NULL が保存されます。設定されたデフォルト値によって保存内容が変わることがあります。詳細については、Null 許容フィールドとデフォルト値を参照してください。

フィールド型	NULL の動作
`VARCHAR`	空文字列 `""` は非 NULL 値です。
`JSON`	フィールド全体の NULL 値は `IS NULL` に一致します。`{"category": null}` のような JSON オブジェクトは、その内部の値が NULL であっても非 NULL です。
`ARRAY`	フィールド全体の NULL 値は `IS NULL` に一致します。個々の要素は NULL にできず、`IS NULL` / `IS NOT NULL` は `tags[0]` のような配列要素へのアクセスをサポートしていません。Array フィールドを参照してください。
通常のベクトル型	NULL はベクトル値が存在しないことを意味します。成分がゼロのベクトルは NULL ではありません。

nullable=False で定義されたサポート対象のフィールドの場合、IS NULL はどのエンティティにも一致せず、IS NOT NULL は表示可能なすべてのエンティティに一致します。フィルタ内のその他の条件は引き続き適用されます。

ベクトル検索での NULL フィルターの使用

同じ演算子を検索フィルターでも使用できますが、類似検索に参加するには、検索対象のフィールドにベクトルを持つエンティティである必要があります。

上記のサンプルデータを使用して、anns_field="embedding" を指定した検索を考えます：

フィルタ式	類似検索の対象となるエンティティ	理由
`category IS NULL`	`2`	エンティティ `2` はカテゴリを持ちませんが、`embedding` ベクトルを持っています。
`embedding IS NULL`	なし	エンティティ `3` はフィルターに一致しますが、クエリベクトルと比較する `embedding` ベクトルを持っていません。
`embedding IS NOT NULL`	`1`, `2`	どちらのエンティティも `embedding` ベクトルを持っています。

3 つのフィルターはすべて有効です。embedding IS NULL を指定して embedding を検索しても、両方の要件を満たせるエンティティがないため、ヒットは返されません。埋め込みが欠落しているエンティティを取得するには、上記のように query() を使用します。

ベクトル検索では、検索対象のベクトルフィールドが NULL であるエンティティはすでにスキップされるため、embedding IS NOT NULL を指定しても embedding の検索候補はさらに絞り込まれません。ランキング、その他のフィルター、検索上限によって、返される候補が決まります。

JSON フィールドと ARRAY フィールドで基本演算子を使用する際のヒント

Zilliz Cloud クラスターの基本演算子は汎用性が高く、スカラーフィールドに適用できますが、JSON フィールドと ARRAY フィールドのキーやインデックスに対しても効果的に使用できます。

たとえば、price、model、tags などの複数のキーを含む product フィールドがある場合は、常にキーを直接参照してください：

python
filter = 'product["price"] > 1000'

java

String filter = "product[\"price\"] > 1000";

go
filter := "product[\"price\"] > 1000"

rust
let filter = "product[\"price\"] > 1000";

c++

std::string filter = "product[\"price\"] > 1000";

javascript
const filter = 'product["price"] > 1000';

bash

filter='product["price"] > 1000'

記録された気温の配列の最初の気温が特定の値を超えるレコードを検索するには、次のようにします：

python
filter = 'history_temperatures[0] > 30'

java

String filter = "history_temperatures[0] > 30";

go
filter := "history_temperatures[0] > 30"

rust
let filter = "history_temperatures[0] > 30";

c++

std::string filter = "history_temperatures[0] > 30";

javascript
const filter = 'history_temperatures[0] > 30';

bash

filter='history_temperatures[0] > 30'

まとめ

Zilliz Cloud は、データのフィルタリングとクエリに柔軟性をもたらすさまざまな基本演算子を提供します。比較演算子、範囲演算子、算術演算子、論理演算子を組み合わせることで、強力なフィルタ式を作成して検索結果を絞り込み、必要なデータを効率的に取得できます。

FAQ

フィルタ条件内のマッチ値リストの長さに制限はありますか（例：filter='color in ["red", "green", "blue"]'）？リストが長すぎる場合はどうすればよいですか？

Zilliz Cloud は、フィルタ条件内のマッチ値リストの長さに制限を設けていません。ただし、リストが過度に長いと、クエリのパフォーマンスに大きく影響する可能性があります。フィルタ条件に長いマッチ値リストや、要素の多い複雑な式が含まれる場合は、クエリのパフォーマンスを向上させるためにフィルタテンプレートの使用をお勧めします。

比較演算子​

サポートされる比較演算子：​

例 1：等しい（==）によるフィルタリング​

例 2：等しくない（!=）によるフィルタリング​

例 3：より大きい（>）によるフィルタリング​

例 4：より小さいによるフィルタリング​

例 5：以上（>=）によるフィルタリング​

例 6：以下によるフィルタリング​

範囲演算子​

パターンマッチ演算子​

算術演算子​

サポートされる算術演算子：​

例 1：剰余（%）の使用​

例 2：べき乗（**）の使用​

ビット演算子​

サポートされるビット演算子​

例：パーミッションビットによるフィルタリング​

論理演算子​

サポートされる論理演算子：​

例 1：AND を使用した条件の結合​

例 2：OR を使用した条件の結合​

例 3：NOT を使用した条件の除外​

IS NULL 演算子と IS NOT NULL 演算子​

例：値が欠落しているエンティティまたは利用可能な値を持つエンティティの検索​

フィールド値の扱い​

ベクトル検索での NULL フィルターの使用​

JSON フィールドと ARRAY フィールドで基本演算子を使用する際のヒント​

まとめ​

FAQ​

比較演算子

サポートされる比較演算子：

例 1：等しい（`==`）によるフィルタリング

例 2：等しくない（`!=`）によるフィルタリング

例 3：より大きい（`>`）によるフィルタリング

例 4：より小さいによるフィルタリング

例 5：以上（`>=`）によるフィルタリング

例 6：以下によるフィルタリング

範囲演算子

パターンマッチ演算子

算術演算子

サポートされる算術演算子：

例 1：剰余（`%`）の使用

例 2：べき乗（`**`）の使用

ビット演算子

サポートされるビット演算子

例：パーミッションビットによるフィルタリング

論理演算子

サポートされる論理演算子：

例 1：`AND` を使用した条件の結合

例 2：`OR` を使用した条件の結合

例 3：`NOT` を使用した条件の除外

IS NULL 演算子と IS NOT NULL 演算子

例：値が欠落しているエンティティまたは利用可能な値を持つエンティティの検索

フィールド値の扱い

ベクトル検索での NULL フィルターの使用

JSON フィールドと ARRAY フィールドで基本演算子を使用する際のヒント

まとめ

FAQ