[アップデート] Amazon DynamoDB のベクトル検索で範囲比較・IN・OR/NOT のインラインフィルタが使えるようになったので試してみた

[アップデート] Amazon DynamoDB のベクトル検索で範囲比較・IN・OR/NOT のインラインフィルタが使えるようになったので試してみた

Amazon DynamoDB のベクトル検索で、インラインフィルタに範囲比較・IN・OR・NOT が追加されました。アプリ側で絞り込むと 0 件だった「価格 10000 以下」の類似検索が、インラインフィルタでは 5 件返りました。AWS CLI で各演算子の動作と制約を検証します。
2026.11.21

クラウド事業統括本部の石川です。2026年8月にリリースされたばかりのAmazon DynamoDB のベクトル検索に、さらに SearchVectors のインラインフィルタに範囲比較、IN、OR・NOT などの演算子が追加されましたので、実際に試してみました。

https://aws.amazon.com/jp/about-aws/whats-new/2026/11/dynamodb-vector-filters/

Amazon DynamoDB のベクトル検索は 2026 年 8 月に一般提供が始まった機能です。テーブルにベクトルインデックスを作成すると、アイテムに保存したベクトル埋め込みに対して SearchVectors API で近似最近傍探索(ANN)を実行できます。

https://dev.classmethod.jp/articles/dynamodb-realtime-vector-search/

これまで SearchVectors のインラインフィルタで使える演算子は、等価(=)だけでした。今回のアップデートで、次の演算子と関数が使えるようになりました。

  • Number 属性に対する比較演算子 <、<=、>、>= と BETWEEN
  • 値のリストのいずれかに一致するかを判定する IN
  • 属性の有無を判定する attribute_exists と attribute_not_exists
  • 論理演算子 AND、OR、NOT

フィルタは検索の途中で適用されるため、返る結果はすべて条件に一致します。アナウンスでは小売アプリで価格帯とブランドを指定して類似商品を返す例や、RAG(検索拡張生成)アプリで選択したカテゴリかつ指定日以降に公開された文書に絞る例が挙げられています。新しい演算子は、DynamoDB のベクトル検索が利用できるすべてのリージョンで利用できます。

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/VectorSearchFilterReference.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/VectorSearchWorkingWith.html

SearchVectors のインラインフィルタとは

ベクトルインデックスにはベクトル属性のほかに、SearchSchema として 2 種類の属性を宣言できます。

種類 役割 インデックスあたりの上限 検索時の指定
HASH(ベクトルインデックスのパーティションキー) 同じ値を持つベクトルだけを検索対象にする 1 宣言した場合は必須(= のみ)
INLINE_FILTER(インラインフィルタ属性) ベクトルと一緒にインデックスへ保存され、検索中の絞り込みに使われる 18 任意

インラインフィルタ属性の値はインデックス内でベクトルの隣に保存されます。DynamoDB は検索中にフィルタ条件に一致しないベクトルを飛ばすため、インデックス全体を検索してから一致しない結果を捨てる処理にはなりません。SearchSchema に宣言した属性は AttributeDefinitions にも宣言します。また、SearchSchema の属性はベクトルインデックスの作成時にしか追加できません。

インラインフィルタ属性で使える演算子は次のとおりです。

演算子 意味 使える属性の型
= 等価 S / N / B
<> 不等価 S / N / B
IN (:a, :b) 値のリスト(1〜100 個の値)のいずれかに一致 S / N / B
<、<=、>、>= 範囲比較 N のみ
BETWEEN :lo AND :hi 範囲(両端を含む) N のみ

このほか、AND、OR、NOT と括弧で条件を組み合わせられます。関数は attribute_exists と attribute_not_exists の 2 つだけが使え、begins_with、contains、attribute_type、size は拒否されます。

パーティションキー(HASH)の条件には、インラインフィルタより厳しいルールがあります。

  • パーティションキーの条件は 1 つだけで、= を使う
  • 式のトップレベルに置き、ほかの条件とは AND で結合する。OR や NOT の中には置けない
  • <>、範囲比較、BETWEEN、IN(値が 1 つでも)、attribute_exists / attribute_not_exists は使えない
  • 1 回の SearchVectors で検索できるパーティションキーの値は 1 つ。複数の値を検索するには値ごとに呼び出す

属性を持たないアイテムに対する挙動は、演算子によって異なります。

  • =、範囲比較、BETWEEN、IN は、属性がないアイテムにマッチしない
  • <> と NOT は、属性がないアイテムにマッチする
  • 属性がないアイテムを除外したい場合は attribute_exists を併用する

そのほかの制約は次のとおりです。

  • 条件に使えるのはトップレベルの属性だけで、a.b や a[0] のようなネストした属性は指定できない
  • IN のリストに指定できる値は 1〜100 個
  • 式に含められる条件の数と演算子の数には上限がある。比較、BETWEEN、IN、関数呼び出しがそれぞれ 1 条件として数えられ、AND、OR、NOT、括弧は条件として数えない
  • Number の比較は IEEE 754 倍精度浮動小数点数で行われる。保存値と式の値がどちらも有効桁 15 桁以下であれば、Query や Scan と同じ結果になる
  • 条件数の上限を超えると、エラーメッセージに上限値(maximum: <max>)が含まれる
  • 式の検証で誤りが見つかった場合、SearchVectors が返すエラーは 1 つだけで、式のチェック、パーティションキーのチェック、属性のチェックの順に検証される

SearchVectors を使うときの前提は次のとおりです。

  • ベクトルインデックスはオンデマンドキャパシティモード(PAY_PER_REQUEST)のテーブルでのみ使える
  • SearchVector パラメータは L 型で包まない数値オブジェクトの配列([{"N": "1"}, {"N": "0"}, {"N": "0"}, {"N": "0"}])で指定する
  • 既定のレスポンスにはベクトル属性が含まれない。必要な場合は ProjectionExpression で明示的に指定する

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/VectorSearch.html

やってみた

前提条件

  • AWS アカウント(テーブルの作成と dynamodb:SearchVectors を実行できる IAM 権限)
  • 検証リージョン: アジアパシフィック(東京)ap-northeast-1
  • AWS CLI: 2.42.1(search-vectors コマンドは 2.36.16 以降が必要)
  • 検証日: 2026 年 11 月 21 日

検証用データの設計

フィルタの結果が正しいかどうかを判断しやすくするため、埋め込みモデルは使わず、4 次元のベクトルを手作りしました。クエリベクトルを [1, 0, 0, 0] とし、各アイテムのベクトルを [cos θ, sin θ, 0, 0] として、角度 θ を 5° ずつずらしています。距離関数は COSINE(スコアが小さいほど類似)なので、スコアは 1 - cos θ になり、Shoes の類似度の順位は S01 から S16 までの ID 順になります。

価格には境界値の確認用に 8000 と 12000 を含め、SaleTag は SALE、REGULAR、属性なしの 3 状態にしました。Bags の 4 件は、パーティションキーで検索対象が分かれることの確認用です。

検証用データ
ProductId Category 角度 想定スコア(COSINE) Brand Price Rating ReleaseDate SaleTag
S01 Shoes 5° 0.0038 AcmeRun 18900 4.8 20260910 SALE
S02 Shoes 10° 0.0152 AcmeRun 16500 4.6 20260705 (属性なし)
S03 Shoes 15° 0.0341 BravoStep 15800 4.2 20260301 REGULAR
S04 Shoes 20° 0.0603 CirqueFit 14200 4.9 20251120 SALE
S05 Shoes 25° 0.0937 DeltaTrail 13000 3.9 20260815 (属性なし)
S06 Shoes 30° 0.1340 BravoStep 12000 4.4 20260620 SALE
S07 Shoes 35° 0.1808 CirqueFit 11000 3.6 20250930 REGULAR
S08 Shoes 40° 0.2340 AcmeRun 9800 4.1 20260110 (属性なし)
S09 Shoes 45° 0.2929 DeltaTrail 8800 4.7 20260502 SALE
S10 Shoes 50° 0.3572 BravoStep 8000 3.8 20251201 REGULAR
S11 Shoes 55° 0.4264 CirqueFit 7500 4.5 20260918 (属性なし)
S12 Shoes 60° 0.5000 DeltaTrail 6980 3.4 20250610 SALE
S13 Shoes 65° 0.5774 AcmeRun 5980 4.0 20260801 REGULAR
S14 Shoes 70° 0.6580 BravoStep 4980 3.1 20250301 (属性なし)
S15 Shoes 75° 0.7412 CirqueFit 3980 4.3 20261001 SALE
S16 Shoes 80° 0.8264 DeltaTrail 2980 2.9 20240815 REGULAR
B01 Bags 5° 0.0038 AcmeRun 9800 4.5 20260401 SALE
B02 Bags 15° 0.0341 BravoStep 7800 4.0 20260115 (属性なし)
B03 Bags 25° 0.0937 CirqueFit 12800 4.7 20260810 REGULAR
B04 Bags 35° 0.1808 DeltaTrail 5800 3.5 20251010 (属性なし)

ReleaseDate は範囲比較に使うため、yyyymmdd 形式の Number で保存しています。範囲比較が使えるのは Number 属性だけだからです。

1 件分のアイテムは次のとおりです(S02 は SaleTag を持たないアイテムです)。items.json には、この形式のアイテム 20 件を batch-write-item のリクエスト形式で格納しています。

{
  "ProductId": {"S": "S02"},
  "Category": {"S": "Shoes"},
  "ProductName": {"S": "AcmeRun Shoe S02"},
  "Brand": {"S": "AcmeRun"},
  "Price": {"N": "16500"},
  "Rating": {"N": "4.6"},
  "ReleaseDate": {"N": "20260705"},
  "Embedding": {"L": [{"N": "0.984808"}, {"N": "0.173648"}, {"N": "0.0"}, {"N": "0.0"}]}
}

クエリベクトルは、数値オブジェクトの配列として query-vector.json に保存しました。

[{"N": "1"}, {"N": "0"}, {"N": "0"}, {"N": "0"}]

テーブルとベクトルインデックスを作成する

ベクトルインデックスの定義を vector-index.json に用意しました。Category をパーティションキー(HASH)にし、Brand、Price、Rating、ReleaseDate、SaleTag の 5 属性をインラインフィルタとして宣言しています。

[
  {
    "IndexName": "ProductCatalogIndex",
    "VectorAttribute": {
      "AttributeName": "Embedding"
    },
    "Dimensions": 4,
    "DistanceFunction": "COSINE",
    "SearchSchema": [
      {"AttributeName": "Category", "SearchSchemaElementType": "HASH"},
      {"AttributeName": "Brand", "SearchSchemaElementType": "INLINE_FILTER"},
      {"AttributeName": "Price", "SearchSchemaElementType": "INLINE_FILTER"},
      {"AttributeName": "Rating", "SearchSchemaElementType": "INLINE_FILTER"},
      {"AttributeName": "ReleaseDate", "SearchSchemaElementType": "INLINE_FILTER"},
      {"AttributeName": "SaleTag", "SearchSchemaElementType": "INLINE_FILTER"}
    ],
    "Projection": {
      "ProjectionType": "ALL"
    }
  }
]

SearchSchema に宣言した 6 属性は、主キーの ProductId と一緒に attribute-definitions.json にも宣言します。

[
  {"AttributeName": "ProductId", "AttributeType": "S"},
  {"AttributeName": "Category", "AttributeType": "S"},
  {"AttributeName": "Brand", "AttributeType": "S"},
  {"AttributeName": "Price", "AttributeType": "N"},
  {"AttributeName": "Rating", "AttributeType": "N"},
  {"AttributeName": "ReleaseDate", "AttributeType": "N"},
  {"AttributeName": "SaleTag", "AttributeType": "S"}
]

--billing-mode PAY_PER_REQUEST(オンデマンド)を指定して、テーブルとベクトルインデックスを作成しました。

% aws dynamodb create-table \
    --table-name ddb-vector-filter-demo \
    --attribute-definitions file://attribute-definitions.json \
    --key-schema AttributeName=ProductId,KeyType=HASH \
    --billing-mode PAY_PER_REQUEST \
    --vector-indexes file://vector-index.json \
    --tags Key=run_id,Value=ddbvf-20261121-37e9f8a5 Key=owner,Value=tried-it Key=ttl,Value=2026-11-22 Key=purpose,Value=blog-verification
{
    "TableDescription": {
...
        "TableName": "ddb-vector-filter-demo",
...
        "TableStatus": "CREATING",
        "CreationDateTime": "2026-11-21T16:54:25.845000+09:00",
...
        "ItemCount": 0,
...
        "VectorIndexes": [
            {
                "IndexName": "ProductCatalogIndex",
...
                "Dimensions": 4,
                "DistanceFunction": "COSINE",
                "IndexStatus": "CREATING",
                "IndexSizeBytes": 0,
                "ItemCount": 0,
                "IndexArn": "arn:aws:dynamodb:ap-northeast-1:XXXXXXXXXXXX:table/ddb-vector-filter-demo/index/ProductCatalogIndex"
            }
        ]
    }
}

describe-table で状態を確認したところ、テーブル作成から 1 分以内(16:54:25 に作成、16:54:52 に確認)にテーブルとベクトルインデックスが ACTIVE になりました。

% aws dynamodb describe-table --table-name ddb-vector-filter-demo --query 'Table.[TableStatus, VectorIndexes[0].[IndexName, IndexStatus, Dimensions, DistanceFunction]]' --output text
ACTIVE
ProductCatalogIndex	ACTIVE	4	COSINE

マネジメントコンソールのテーブル詳細の「インデックス」タブでも、ベクトルインデックスのパーティションキーとインラインフィルター属性を確認できました。

データを投入する

20 件のアイテムを batch-write-item で投入しました。

% aws dynamodb batch-write-item --request-items file://items.json
{
    "UnprocessedItems": {}
}

投入直後に Shoes を TopK 100 で検索したところ、最初の 1 回で Shoes の 16 件がすべて返りました。

% aws dynamodb search-vectors --table-name ddb-vector-filter-demo --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json --top-k 100 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --query 'length(SearchResults)' --output text
16

パーティションキーだけで検索する

最初に、パーティションキーの条件 Category = :c だけで検索し、レスポンスの形を確認しました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 2 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}'
{
    "SearchResults": [
        {
            "Item": {
                "ProductId": {
                    "S": "S01"
                },
                "ProductName": {
                    "S": "AcmeRun Shoe S01"
                },
                "Price": {
                    "N": "18900"
                },
                "Brand": {
                    "S": "AcmeRun"
                },
                "Category": {
                    "S": "Shoes"
                },
                "Rating": {
                    "N": "4.8"
                },
                "SaleTag": {
                    "S": "SALE"
                },
                "ReleaseDate": {
                    "N": "20260910"
                }
            },
            "Score": 0.0038053379394114017
        },
...
    ]
}

SearchResults の各要素に Item と Score が入ります。Projection は ALL ですが、ベクトル属性の Embedding はレスポンスに含まれていませんでした。

以降は結果を読みやすくするため、--query で ProductId、Brand、Price、Rating、ReleaseDate、SaleTag、Score の順に取り出し、--output table で表示します。CLI の table 表示では属性を持たないアイテムの列に None と表示されます。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S01|  AcmeRun    |  18900 |  4.8 |  20260910 |  SALE    |  0.0038053379394114017   |
|  S02|  AcmeRun    |  16500 |  4.6 |  20260705 |  None    |  0.01519220694899559     |
|  S03|  BravoStep  |  15800 |  4.2 |  20260301 |  REGULAR |  0.034074123948812485    |
|  S04|  CirqueFit  |  14200 |  4.9 |  20251120 |  SALE    |  0.060307249426841736    |
|  S05|  DeltaTrail |  13000 |  3.9 |  20260815 |  None    |  0.0936921164393425      |
+-----+-------------+--------+------+-----------+----------+--------------------------+

想定どおり、S01 から S05 がスコアの小さい順に返りました。パーティションキーの値を Bags に変えると、Bags の 4 件だけが返りました。S01 と B01 は同じベクトルですが、Bags の検索では S01 が返らないので、検索対象がパーティションキーの値で分かれていることが分かります。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Bags"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  B01|  AcmeRun    |  9800  |  4.5 |  20260401 |  SALE    |  0.0038053379394114017   |
|  B02|  BravoStep  |  7800  |  4   |  20260115 |  None    |  0.034074123948812485    |
|  B03|  CirqueFit  |  12800 |  4.7 |  20260810 |  REGULAR |  0.0936921164393425      |
|  B04|  DeltaTrail |  5800  |  3.5 |  20251010 |  None    |  0.18084770441055298     |
+-----+-------------+--------+------+-----------+----------+--------------------------+

比較のため、以前から使えた等価条件のインラインフィルタも実行しました。BravoStep の 4 件が返りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Brand = :b" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":b":{"S":"BravoStep"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S03|  BravoStep |  15800 |  4.2 |  20260301 |  REGULAR |  0.034074123948812485   |
|  S06|  BravoStep |  12000 |  4.4 |  20260620 |  SALE    |  0.13397471606731415    |
|  S10|  BravoStep |  8000  |  3.8 |  20251201 |  REGULAR |  0.35721200704574585    |
|  S14|  BravoStep |  4980  |  3.1 |  20250301 |  None    |  0.6579800844192505     |
+-----+------------+--------+------+-----------+----------+-------------------------+

BETWEEN と比較演算子による範囲比較

ここからが今回のアップデートで追加された演算子です。まず BETWEEN で価格帯を 8000〜12000 に絞りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 10 \
    --search-condition-expression "Category = :c AND Price BETWEEN :lo AND :hi" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":lo":{"N":"8000"},":hi":{"N":"12000"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S06|  BravoStep  |  12000 |  4.4 |  20260620 |  SALE    |  0.13397471606731415   |
|  S07|  CirqueFit  |  11000 |  3.6 |  20250930 |  REGULAR |  0.18084770441055298   |
|  S08|  AcmeRun    |  9800  |  4.1 |  20260110 |  None    |  0.233955979347229     |
|  S09|  DeltaTrail |  8800  |  4.7 |  20260502 |  SALE    |  0.2928931713104248    |
|  S10|  BravoStep  |  8000  |  3.8 |  20251201 |  REGULAR |  0.35721200704574585   |
+-----+-------------+--------+------+-----------+----------+------------------------+

上限の 12000(S06)と下限の 8000(S10)がどちらも含まれており、BETWEEN が両端を含むことを確認できました。

次に、境界値 8000 で < と <= の違いを確認しました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 3 \
    --search-condition-expression "Category = :c AND Price < :p" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":p":{"N":"8000"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S11|  CirqueFit  |  7500 |  4.5 |  20260918 |  None    |  0.4264238178730011   |
|  S12|  DeltaTrail |  6980 |  3.4 |  20250610 |  SALE    |  0.4999998211860657   |
|  S13|  AcmeRun    |  5980 |  4   |  20260801 |  REGULAR |  0.5773820281028748   |
+-----+-------------+-------+------+-----------+----------+-----------------------+
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 3 \
    --search-condition-expression "Category = :c AND Price <= :p" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":p":{"N":"8000"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S10|  BravoStep  |  8000 |  3.8 |  20251201 |  REGULAR |  0.35721200704574585   |
|  S11|  CirqueFit  |  7500 |  4.5 |  20260918 |  None    |  0.4264238178730011    |
|  S12|  DeltaTrail |  6980 |  3.4 |  20250610 |  SALE    |  0.4999998211860657    |
+-----+-------------+-------+------+-----------+----------+------------------------+

< では価格 8000 の S10 が含まれず、<= では S10 が先頭に入りました。

アナウンスにある「指定日以降に公開されたもの」に相当する条件として、発売日(ReleaseDate)が 2026 年 6 月 1 日以降の商品に絞りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 10 \
    --search-condition-expression "Category = :c AND ReleaseDate >= :d" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":d":{"N":"20260601"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S01|  AcmeRun    |  18900 |  4.8 |  20260910 |  SALE    |  0.0038053379394114017   |
|  S02|  AcmeRun    |  16500 |  4.6 |  20260705 |  None    |  0.01519220694899559     |
|  S05|  DeltaTrail |  13000 |  3.9 |  20260815 |  None    |  0.0936921164393425      |
|  S06|  BravoStep  |  12000 |  4.4 |  20260620 |  SALE    |  0.13397471606731415     |
|  S11|  CirqueFit  |  7500  |  4.5 |  20260918 |  None    |  0.4264238178730011      |
|  S13|  AcmeRun    |  5980  |  4   |  20260801 |  REGULAR |  0.5773820281028748      |
|  S15|  CirqueFit  |  3980  |  4.3 |  20261001 |  SALE    |  0.7411810159683228      |
+-----+-------------+--------+------+-----------+----------+--------------------------+

このほか、Rating >= 4.5 では評価 4.5 以上の 5 件(S01、S02、S04、S09、S11)、上下限を同じ 8000 にした BETWEEN では S10 の 1 件だけが返りました。上下限が同じ BETWEEN は、ドキュメントのとおり = と同じ結果になります。

IN による値のリストの指定

IN で複数のブランドを指定しました。AcmeRun と CirqueFit の商品だけがスコア順に 5 件返りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Brand IN (:b1, :b2)" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":b1":{"S":"AcmeRun"},":b2":{"S":"CirqueFit"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S01|  AcmeRun   |  18900 |  4.8 |  20260910 |  SALE    |  0.0038053379394114017   |
|  S02|  AcmeRun   |  16500 |  4.6 |  20260705 |  None    |  0.01519220694899559     |
|  S04|  CirqueFit |  14200 |  4.9 |  20251120 |  SALE    |  0.060307249426841736    |
|  S07|  CirqueFit |  11000 |  3.6 |  20250930 |  REGULAR |  0.18084770441055298     |
|  S08|  AcmeRun   |  9800  |  4.1 |  20260110 |  None    |  0.233955979347229       |
+-----+------------+--------+------+-----------+----------+--------------------------+

IN は Number 属性にも使えます。Price IN (:p1, :p2) に 8000 と 12000 を指定すると、S06 と S10 の 2 件が返りました。

OR・NOT と括弧による条件の組み合わせ

ドキュメントの例と同じ形で、「AcmeRun か BravoStep のいずれか、または価格が 3000〜4000」という条件を括弧でまとめ、パーティションキーの条件と AND で結合しました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 10 \
    --search-condition-expression "Category = :c AND (Brand IN (:b1, :b2) OR Price BETWEEN :lo AND :hi)" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":b1":{"S":"AcmeRun"},":b2":{"S":"BravoStep"},":lo":{"N":"3000"},":hi":{"N":"4000"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S01|  AcmeRun   |  18900 |  4.8 |  20260910 |  SALE    |  0.0038053379394114017   |
|  S02|  AcmeRun   |  16500 |  4.6 |  20260705 |  None    |  0.01519220694899559     |
|  S03|  BravoStep |  15800 |  4.2 |  20260301 |  REGULAR |  0.034074123948812485    |
|  S06|  BravoStep |  12000 |  4.4 |  20260620 |  SALE    |  0.13397471606731415     |
|  S08|  AcmeRun   |  9800  |  4.1 |  20260110 |  None    |  0.233955979347229       |
|  S10|  BravoStep |  8000  |  3.8 |  20251201 |  REGULAR |  0.35721200704574585     |
|  S13|  AcmeRun   |  5980  |  4   |  20260801 |  REGULAR |  0.5773820281028748      |
|  S14|  BravoStep |  4980  |  3.1 |  20250301 |  None    |  0.6579800844192505      |
|  S15|  CirqueFit |  3980  |  4.3 |  20261001 |  SALE    |  0.7411810159683228      |
+-----+------------+--------+------+-----------+----------+--------------------------+

AcmeRun と BravoStep の 8 件に加えて、CirqueFit でも価格が 3980 の S15 が返りました。OR の両側の条件がそれぞれ評価されていることが分かります。

NOT (Brand = :b) で AcmeRun を除外すると、AcmeRun 以外の上位 5 件(S03〜S07)が返りました。

最後に、「2026 年 6 月 1 日以降の発売」「評価 4.0 以上」「AcmeRun 以外」の 3 条件を組み合わせました。データの表と照らし合わせると、S06、S11、S15 の 3 件が条件に一致し、そのとおりの結果になりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 10 \
    --search-condition-expression "Category = :c AND ReleaseDate >= :d AND Rating >= :r AND NOT Brand = :b" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":d":{"N":"20260601"},":r":{"N":"4.0"},":b":{"S":"AcmeRun"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S06|  BravoStep |  12000 |  4.4 |  20260620 |  SALE |  0.13397471606731415   |
|  S11|  CirqueFit |  7500  |  4.5 |  20260918 |  None |  0.4264238178730011    |
|  S15|  CirqueFit |  3980  |  4.3 |  20261001 |  SALE |  0.7411810159683228    |
+-----+------------+--------+------+-----------+-------+------------------------+

attribute_exists と attribute_not_exists による属性の有無の判定

SaleTag 属性を持つかどうかで絞り込みました。ここからは出力を ProductId、SaleTag、Score に絞り、TopK を Shoes の全件にあたる 16 にしています。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c AND attribute_exists(SaleTag)" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.SaleTag.S, Score]' --output table
...
|  S01|  SALE     |  0.0038053379394114017  |
|  S03|  REGULAR  |  0.034074123948812485   |
|  S04|  SALE     |  0.060307249426841736   |
|  S06|  SALE     |  0.13397471606731415    |
|  S07|  REGULAR  |  0.18084770441055298    |
|  S09|  SALE     |  0.2928931713104248     |
|  S10|  REGULAR  |  0.35721200704574585    |
|  S12|  SALE     |  0.4999998211860657     |
|  S13|  REGULAR  |  0.5773820281028748     |
|  S15|  SALE     |  0.7411810159683228     |
|  S16|  REGULAR  |  0.826352059841156      |
+-----+-----------+-------------------------+
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c AND attribute_not_exists(SaleTag)" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.SaleTag.S, Score]' --output table
...
|  S02|  None |  0.01519220694899559   |
|  S05|  None |  0.0936921164393425    |
|  S08|  None |  0.233955979347229     |
|  S11|  None |  0.4264238178730011    |
|  S14|  None |  0.6579800844192505    |
+-----+-------+------------------------+

attribute_exists で SaleTag を持つ 11 件、attribute_not_exists で持たない 5 件が返りました。

続いて、<> と NOT が SaleTag 属性のないアイテムをどう扱うかを確認しました。Shoes のうち SaleTag が SALE のアイテムは 6 件です。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c AND SaleTag <> :s" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":s":{"S":"SALE"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.SaleTag.S, Score]' --output table
...
|  S02|  None     |  0.01519220694899559   |
|  S03|  REGULAR  |  0.034074123948812485  |
|  S05|  None     |  0.0936921164393425    |
|  S07|  REGULAR  |  0.18084770441055298   |
|  S08|  None     |  0.233955979347229     |
|  S10|  REGULAR  |  0.35721200704574585   |
|  S11|  None     |  0.4264238178730011    |
|  S13|  REGULAR  |  0.5773820281028748    |
|  S14|  None     |  0.6579800844192505    |
|  S16|  REGULAR  |  0.826352059841156     |
+-----+-----------+------------------------+
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c AND NOT (SaleTag = :s)" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":s":{"S":"SALE"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.SaleTag.S, Score]' --output table
...

SaleTag <> :s と NOT (SaleTag = :s) はどちらも同じ 10 件を返し、その中には REGULAR の 5 件に加えて SaleTag を持たない 5 件(None の行)が含まれていました。値が REGULAR のアイテムだけに絞りたい場合は、attribute_exists を併用します。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c AND SaleTag <> :s AND attribute_exists(SaleTag)" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":s":{"S":"SALE"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.SaleTag.S, Score]' --output table
...
|  S03|  REGULAR  |  0.034074123948812485  |
|  S07|  REGULAR  |  0.18084770441055298   |
|  S10|  REGULAR  |  0.35721200704574585   |
|  S13|  REGULAR  |  0.5773820281028748    |
|  S16|  REGULAR  |  0.826352059841156     |
+-----+-----------+------------------------+

インラインフィルタとクライアント側のポストフィルタを比べる

検索結果をアプリケーション側で絞り込むポストフィルタと、インラインフィルタの違いを確認しました。ポストフィルタはフィルタなしで取得した TopK 5 件に対して、CLI の --query(JMESPath)で Price <= 10000 の条件をかけて再現しています。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --query 'SearchResults[?to_number(Item.Price.N) <= `10000`].[Item.ProductId.S, Item.Price.N, Score]' --output json
[]

類似度の上位 5 件(S01〜S05)はいずれも 13000 以上のため、ポストフィルタの結果は 0 件になりました。同じ条件をインラインフィルタで指定すると、10000 以下の商品が 5 件返りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Price <= :p" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":p":{"N":"10000"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S08|  AcmeRun    |  9800 |  4.1 |  20260110 |  None    |  0.233955979347229     |
|  S09|  DeltaTrail |  8800 |  4.7 |  20260502 |  SALE    |  0.2928931713104248    |
|  S10|  BravoStep  |  8000 |  3.8 |  20251201 |  REGULAR |  0.35721200704574585   |
|  S11|  CirqueFit  |  7500 |  4.5 |  20260918 |  None    |  0.4264238178730011    |
|  S12|  DeltaTrail |  6980 |  3.4 |  20250610 |  SALE    |  0.4999998211860657    |
+-----+-------------+-------+------+-----------+----------+------------------------+

ただし、インラインフィルタでも常に TopK 件が返るわけではありません。条件に一致するアイテムが TopK より少なければ、一致した分だけが返ります。評価 4.8 以上は S01 と S04 の 2 件だけなので、TopK 5 でも 2 件でした。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Rating >= :r" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":r":{"N":"4.8"}}' \
    --query 'SearchResults[].[Item.ProductId.S, Item.Brand.S, Item.Price.N, Item.Rating.N, Item.ReleaseDate.N, Item.SaleTag.S, Score]' --output table
...
|  S01|  AcmeRun   |  18900 |  4.8 |  20260910 |  SALE |  0.0038053379394114017   |
|  S04|  CirqueFit |  14200 |  4.9 |  20251120 |  SALE |  0.060307249426841736    |
+-----+------------+--------+------+-----------+-------+--------------------------+

条件に一致するアイテムがない場合は、エラーではなく空の SearchResults が返りました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Price > :p" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":p":{"N":"20000"}}'
{
    "SearchResults": []
}

エラーになる書き方を確認する

誤りを 1 つだけ含めた式をそれぞれ実行し、どのようなメッセージが返るかを確認しました。

String 属性の Brand に範囲比較 > を使うと、Number 属性にしか使えないというエラーになりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Brand > :b" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":b":{"S":"B"}}'

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: SearchConditionExpression allows this operator only on Number (N) attributes; operator: >, attribute: Brand, attribute type: S

パーティションキーの条件を OR の中に置くと、エラーになりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c OR Brand = :b" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":b":{"S":"AcmeRun"}}'

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: SearchConditionExpression must use = on the HASH attribute, not inside OR or NOT; HASH attribute: Category

パーティションキーの条件を省略すると、HASH 属性がすべて含まれていないというエラーになりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Brand = :b" \
    --expression-attribute-values '{":b":{"S":"AcmeRun"}}'

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: SearchConditionExpression must have all HASH attributes in configured SearchSchema

SearchSchema に宣言していない ProductName を条件に使うと、エラーになりました。ProductName は Projection ALL でインデックスに射影されていますが、射影されていてもインラインフィルタとして宣言していない属性は条件に使えません。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND ProductName = :n" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":n":{"S":"AcmeRun Shoe S01"}}'

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: SearchConditionExpression must not contain any attributes that is not in SearchSchema. Invalid attribute: ProductName

確認したエラーを次の表にまとめます。いずれのメッセージもドキュメントの「Validation error messages」の一覧に載っているものでした。表のうち、begins_with、パーティションキーへの IN、値の型の不一致、BETWEEN の下限と上限の 4 つは、コマンドと出力を省略しています。

誤りの内容 エラーメッセージ(抜粋)
String 属性に範囲比較 allows this operator only on Number (N) attributes
パーティションキーの条件を OR の中に置く must use = on the HASH attribute, not inside OR or NOT
パーティションキーに IN must use = on the HASH attribute, not inside OR or NOT
パーティションキーの条件がない must have all HASH attributes in configured SearchSchema
begins_with を使う The function is not allowed in a search condition
SearchSchema にない属性を使う must not contain any attributes that is not in SearchSchema
値の型が SearchSchema と違う does not match type in search schema
BETWEEN の下限 > 上限 requires upper bound to be greater than or equal to lower bound

条件数と IN の値の数の上限を確認する

今回参照したドキュメントのページでは、条件数の上限の具体的な値を確認できませんでした。そこで、上限を超えたときのエラーメッセージで上限値を確認するため、条件が多い式を作って試しました。式と値は長くなるので、ファイルに書き出して file:// で渡しています。

まず、パーティションキーの条件 1 つと、OR でつないだ Price = :pN を 49 個(1000〜49000)並べた、合計 50 条件の式です。

Category = :c AND (Price = :p1 OR Price = :p2 OR Price = :p3 OR Price = :p4 OR Price = :p5 OR Price = :p6 OR Price = :p7 OR Price = :p8 OR Price = :p9 OR Price = :p10 OR Price = :p11 OR Price = :p12 OR Price = :p13 OR Price = :p14 OR Price = :p15 OR Price = :p16 OR Price = :p17 OR Price = :p18 OR Price = :p19 OR Price = :p20 OR Price = :p21 OR Price = :p22 OR Price = :p23 OR Price = :p24 OR Price = :p25 OR Price = :p26 OR Price = :p27 OR Price = :p28 OR Price = :p29 OR Price = :p30 OR Price = :p31 OR Price = :p32 OR Price = :p33 OR Price = :p34 OR Price = :p35 OR Price = :p36 OR Price = :p37 OR Price = :p38 OR Price = :p39 OR Price = :p40 OR Price = :p41 OR Price = :p42 OR Price = :p43 OR Price = :p44 OR Price = :p45 OR Price = :p46 OR Price = :p47 OR Price = :p48 OR Price = :p49)
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression file://cond-50.txt \
    --expression-attribute-values file://values-50.json
{
    "SearchResults": [
        {
            "Item": {
                "ProductId": {
                    "S": "S05"
                },
...
            "Score": 0.0936921164393425
        },
...
    ]
}

50 条件の式はエラーにならず、価格が 1000〜49000 の 1000 刻みの値に一致する S05、S06、S07、S10 の 4 件が返りました。

同じ形で Price = :pN を 199 個(100〜19900)に増やし、合計 200 条件にしたところ、条件数ではなく演算子数の上限でエラーになりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression file://cond-200.txt \
    --expression-attribute-values file://values-200.json \
    --query 'SearchResults[].Item.ProductId.S' --output text

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: Invalid SearchConditionExpression: The expression contains too many operators; operator count: 399

399 は比較演算子 = の 200 個、OR の 198 個、AND の 1 個の合計と一致します。今回の 2 回の試行では、条件数の上限値そのものは確認できませんでした。

IN のリストに 101 個の値を指定すると、ドキュメントどおり上限(100 個)を超えたというエラーになりました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression file://in-101.txt \
    --expression-attribute-values file://values-in-101.json

aws: [ERROR]: An error occurred (ValidationException) when calling the SearchVectors operation: Invalid SearchConditionExpression: The IN operator is provided with too many operands; number of operands: 101

消費キャパシティを確認する

--return-consumed-capacity を指定すると、検索で処理したバイト数が VectorSearchRequestBytes として返ります。フィルタの有無と TopK を変えて比べました。

% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --return-consumed-capacity INDEXES \
    --query 'ConsumedCapacity'
{
    "VectorSearchRequestBytes": 1024.0
}
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 5 \
    --search-condition-expression "Category = :c AND Price <= :p" \
    --expression-attribute-values '{":c":{"S":"Shoes"},":p":{"N":"10000"}}' \
    --return-consumed-capacity INDEXES \
    --query 'ConsumedCapacity'
{
    "VectorSearchRequestBytes": 1024.0
}
% aws dynamodb search-vectors \
    --table-name ddb-vector-filter-demo \
    --index-name ProductCatalogIndex \
    --search-vector file://query-vector.json \
    --top-k 16 \
    --search-condition-expression "Category = :c" \
    --expression-attribute-values '{":c":{"S":"Shoes"}}' \
    --return-consumed-capacity INDEXES \
    --query 'ConsumedCapacity'
{
    "VectorSearchRequestBytes": 2190.0
}

TopK 5 ではフィルタの有無にかかわらず 1024 バイトで、差は表れませんでした。TopK を 16 にすると 2190 バイトになりました。

マネジメントコンソールから検索する

マネジメントコンソールの「項目を探索」で「検索」を選び、ベクトルインデックスを指定すると、ベクトル検索の入力画面が表示されます。検索ベクトルに [1, 0, 0, 0]、結果の数(トップ K)に 5、パーティションキーに Shoes を入力して実行すると、CLI と同じく S01、S02 の順に結果が返りました。

検証時点(2026 年 11 月 21 日)のコンソールでは、インラインフィルター属性の「条件」は「次と等しい」と表示されたラベルで、演算子を選ぶ項目はありませんでした。今回追加された範囲比較や IN、OR を使う場合は、CLI か SDK から SearchVectors を呼び出します。なお、検索結果のバナーに表示される消費キャパシティの値は、{{vectorSearchCapacityUnits}} のようなプレースホルダーのままでした。

後片付け

検証が終わったので、テーブルを削除しました。ベクトルインデックスもテーブルと一緒に削除されます。

% aws dynamodb delete-table --table-name ddb-vector-filter-demo --query 'TableDescription.[TableName, TableStatus]' --output text
ddb-vector-filter-demo	DELETING
% aws dynamodb wait table-not-exists --table-name ddb-vector-filter-demo

考察

1 回の SearchVectors での条件の組み合わせ

これまでは等価条件しか使えなかったため、価格帯や複数ブランドで絞り込むには、SearchVectors の結果をアプリケーション側で絞り込む方法が考えられました。その場合、今回の比較のように、TopK 件の中に条件に合うアイテムがなければ結果は 0 件です。今回のアップデートで、価格帯とブランド、公開日とカテゴリといった条件を 1 回の SearchVectors に含め、条件に一致するアイテムの中から類似度の高い順に取得できるようになりました。

<> と NOT での属性がないアイテムの扱い

SaleTag <> "SALE" や NOT (SaleTag = "SALE") は、SaleTag 属性がないアイテムも返しました。省略可能な属性を否定条件で使う場合は、属性がないアイテムを結果に含めてよいかを決め、含めない場合は attribute_exists を併用します。

インラインフィルタ属性の設計

SearchSchema の属性はインデックス作成後に追加できず、インラインフィルタ属性はインデックスあたり最大 18 個です。設定を変えるには新しいベクトルインデックスを作成します。AWS のブログによると、既存のテーブルにベクトルインデックスを追加したときのバックフィルは無料です。フィルタに使う可能性がある属性は、インデックスを作る前に洗い出しておくのがよいと考えます。

型の選び方にも注意が必要です。範囲比較が使えるのは Number 属性だけなので、今回の ReleaseDate のように日付を範囲で絞りたい場合は Number で保存します。一方、Number の比較は倍精度浮動小数点数で行われます。有効桁が 16 桁以上の値(ナノ秒単位のエポック時刻や 64 ビットの識別子など)を区別したい場合について、ドキュメントでは値を String で保存し、範囲で絞るための日単位などの属性を別に用意する方法が案内されています。

パーティションキーとインラインフィルタの使い分け

パーティションキーに使える演算子は = だけで、1 回の検索で指定できる値は 1 つです。今回も Category IN (:c1, :c2) はエラーになりました。複数の値をまとめて検索したい属性は、パーティションキーではなくインラインフィルタ属性にすると IN や OR で指定できます。一方、ドキュメントによると、パーティションキーは検索対象をその値のベクトルに限定するため、インデックスが大きい場合や検索回数が多い場合に検索のレイテンシーを下げ、パーティションキーの値ごとにスループットを分散できます。検索パターンに合わせて、どの属性をパーティションキーにするかを決める必要があります。

また、パーティションキーで検索対象を分けても、アクセス制御にはなりません。SearchVectors では fine-grained access control(FGAC)が使えないため、dynamodb:SearchVectors 権限を持つプリンシパルは任意のパーティションキーの値を検索できます。テナントごとにデータを厳密に分離する必要がある場合は、ドキュメントにあるとおり、テーブルやインデックスを分けて IAM の権限を分けます。

条件数と演算子数の上限

200 条件の式は、条件数より先に演算子数の上限で拒否されました。同じ属性に対する値の候補を並べる場合は、OR で = をつなぐより IN(最大 100 個)を使うほうが、式を短くできます。ドキュメントによると、IN は値がいくつあっても 1 条件として数えられます。

その他の注意点

  • 今回は 20 件の小さなデータで、ベクトルの距離の順位を意図的に固定して確認しました。ベクトル検索は近似最近傍探索(ANN)なので、大規模なデータでの再現率(recall)は今回の結果からは判断できません
  • 検索の課金は処理したバイト数で計量され、1 リクエストあたり最小 1KB です。ドキュメントによると、VectorSearchRequestBytes には返却されるデータも含まれ、TopK と射影する属性に応じて増えます。TopK 5 の 1024 バイトは最小値に収まったため、TopK 16 の 2190 バイトは返却データが増えたためと考えられます
  • ベクトルインデックスへの反映は非同期で、検索結果は結果整合性です。今回は投入直後の検索に反映されていましたが、遅延が生じる場合があるとドキュメントに書かれています
  • インデックスが ACTIVE になった直後は SearchVectors が ValidationException を返す場合があるため、ドキュメントでは、SearchVectors をリトライして最初に成功した時点を準備完了とみなす方法が案内されています
  • コンソールの検索画面は検証時点では等価条件の入力にのみ対応していました

今後、次のような機能拡張を期待しています。

  • コンソールの検索画面での範囲比較、IN、OR、NOT の指定
  • String 属性に対する begins_with などの前方一致や範囲比較
  • ネストした属性に対する条件の指定

最後に

Amazon DynamoDB のベクトル検索で、SearchVectors のインラインフィルタに範囲比較、IN、OR・NOT、attribute_exists・attribute_not_exists が追加されました。実際に試したところ、いずれの演算子もドキュメントどおりに動き、価格帯や公開日、複数ブランドといった条件を 1 回の検索で指定して、条件に一致する商品を類似度順に取得できました。同じ TopK でも、アプリケーション側で絞り込む方法では 0 件だった条件で、インラインフィルタでは 5 件が返りました。

一方で、<> と NOT が属性のないアイテムを含むこと、パーティションキーは = で 1 つの値しか指定できないこと、インラインフィルタ属性がインデックス作成時にしか追加できないことは、設計時に押さえておく必要があります。DynamoDB のベクトル検索を使っている場合は、これまでアプリケーション側で行っていた絞り込みを SearchConditionExpression に移せるか確認してみてください。これから使う場合は、フィルタに使う属性と型をインデックス作成前に決めておくことをおすすめします。

この記事をシェアする

AWSのお困り事はクラスメソッドへ

関連記事