SEARCH

用途

ベクトルおよびキーワードで検索します。この機能を使用すると、次のタスクを実行できます:

テキスト・ドキュメントとベクトル化されたチャンクの結合された(ハイブリッド)問合せの促進:

「ハイブリッド検索の理解」で説明されているように、検索モードと呼ばれる複数のベクトル検索およびキーワード検索の組合せでハイブリッド・ベクトル索引を問い合せることができます。このAPIは、すべての問合せパラメータでJSONによる指定を受け入れます。
検索結果の融合および並替え:

ハイブリッド問合せの検索結果は、指定された融合セット演算子を使用して統合結果セットにCLOBとして融合され、指定されたスコアリング・アルゴリズムを使用して結合スコアで並べ替えられます。
簡略化された検索エクスペリエンスのためのデフォルトの問合せの実行:

最低限必要な入力パラメータは、hybrid_index_nameおよびsearch_textです。同じテキスト文字列が、ベクトル化されたチャンク索引およびテキスト・ドキュメント索引に対する問合せに使用されます。

構文

DBMS_HYBRID_VECTOR.SEARCH(
   json(
     '{  "hybrid_index_name"     :  "<hybrid_vector_index_name>",                  
         "search_text"           :  "<query string for keyword-and-semantic search>",                   
         "search_fusion"         :  one of these values : "INTERSECT | UNION | TEXT_ONLY | VECTOR_ONLY | MINUS_TEXT | 
                                         MINUS_VECTOR | RERANK",      
         "search_scorer"         :  one of these values : "RRF | RSF",    
         "vector":
           {
            "search_text"             :  "<query string for semantic search>",            
            "search_vector"           :  "<vector_embedding>",           
            "search_mode"             :  one of thse values : "DOCUMENT | CHUNK",                 
            "aggregator"              :  one of these values : "COUNT | SUM | MIN | MAX | AVG | MEDIAN | BONUSMAX | WINAVG | 
                                         ADJBOOST | MAXAVGMED",  
            "result_max"              :  <maximum number of vector results>,
            "score_weight"            :  <weight of vector score for RSF>,
            "rank_penalty"            :  <penalty of vector ranking for RRF>, 
            "inpath"                  :  <an array of valid JSON paths>,
            "accuracy"                :  <target accuracy for semantic search>,
            "index_probes"            :  <neighbor partitions for semantic search>,
            "index_efsearch"          :  <efsearch for semantic search>,
            "filter_type"             :  one of these values : "IN_WO | IN_W | PRE_WO | PRE_W | POST_WO | DEFAULT"  
           },
         "text":
           {
            "contains"                :  "<query string for keyword search>",    
            "search_text"             :  "<alternative text to use to construct a contains query automatically>",  
            "json_textcontains"       :  <an array of valid JSON path and a query string>,   
            "score_weight"            :  <weight of text score for RSF>,
            "rank_penalty"            :  <penalty of text ranking for RRF>,
            "result_max:              :  <maximum number of document results>,
            "inpath"                  :  <array of valid JSON paths>      
           },
         "filter_by":
           {
            "op"                      :  one of these values: "< | > | <= | >= | = | != | ^- | <> | LIKE | LIKEC | LIKE2 | LIKE4 |
                                         REGEXP_LIKE | BETWEEN | EXISTS | INSTR | INSTRC | INSTR2 | INSTR4 | STSTR | STSTR2 | STSTR4 |
                                         STSTRB | STSTRC | <ANY | >ANY | <=ANY | >=ANY | =ANY | !=ANY | <SOME | >SOME | 
                                         <=SOME | >=SOME | =SOME | !=SOME | <ALL | >ALL | <=ALL | >=ALL | =ALL | !=ALL | IN |
                                         AND | OR | NOT | NOTOR | NOTAND",                               
            "type"                    :  one of these values : "number | string | date | timestamp", 
            "col"                     :  "<base table column name>",
            "path"                    :  "<JSON path dot notation within a base table JSON column>", 
            "func"                    :  one of these values : "ABS | FLOOR | LENGTH | CEILING | UPPER | LOWER | TO_BOOLEAN | 
                                         TO_DATE | TO_DOUBLE | TO_BINARYDOUBLE | TO_NUMBER | TO_CHAR | TO_TIMESTAMP", 
            "args"                    :  <an array of arguments to the operator>                        
           }
         "return":
           {
            "topN"                    :  <topN_value>,                               
            "values"                  :  one or more of these values : "rowid | score | vector_score | text_score | vector_rank | 
                                         text_rank | chunk_text | chunk_id | paths",                                
            "format"                  :  one of these values : "JSON | XML"                              
           }
     }'
  )
)

ノート:

このAPIは、2つの検索構造をサポートしています。1つはセマンティック検索とキーワード検索の両方に単一のsearch_textフィールドを指定する方法です(デフォルト設定)。もう1つはセマンティック検索およびキーワード検索にそれぞれvectorおよびtextサブ要素を使用して、個別のsearch_textおよびcontains問合せフィールドを指定する方法です。1つの問合せでこれらの両方の検索構造を使用することはできません。

hybrid_index_name

使用するハイブリッド・ベクトル索引の名前を指定します。

ハイブリッド・ベクトル索引を作成する方法の詳細は(まだ作成していない場合)、「ハイブリッド・ベクトル索引の管理」を参照してください。

search_text

セマンティック検索とキーワード検索の両方の検索テキスト文字列(問合せ入力)を指定します。

ドキュメント・テキスト索引に対するキーワード問合せ(search_textをCONTAINS ACCUM演算子構文に変換)およびベクトル化チャンク索引に対するセマンティック問合せ(VECTOR_DISTANCE検索のsearch_textをベクトル化または埋込み)に同じテキスト文字列が使用されます。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "search_text"       : "C, Python"
          }'))
FROM DUAL;

search_fusion

融合ソート演算子を指定して、キーワード検索とセマンティック検索の結果の結合されたセットから保持する内容を定義します。

ノート:

この検索融合操作は、純粋ではないハイブリッド検索の場合にのみ適用されます。ベクトルのみおよびテキストのみの検索では、結果は融合されません。

パラメータ	説明
`INTERSECT`	テキスト検索結果とベクトル検索結果の両方に共通する行のみを返します。スコア条件: `text_score > 0 AND vector_score > 0`
`UNION` (デフォルト)	テキスト検索結果とベクトル検索結果の両方からのすべての個別行を結合します。スコア条件: `text_score > 0 OR vector_score > 0`
`TEXT_ONLY`	テキスト検索結果のすべての個別行と、テキスト検索結果とベクトル検索結果の両方に共通する行を返します。このため、融合した結果には、テキスト検索に表示されるテキスト検索結果(両方に表示されるものを含む)が含まれます。スコア条件: `text_score > 0`
`VECTOR_ONLY`	ベクトル検索結果のすべての個別行と、テキスト検索結果とベクトル検索結果の両方に共通する行を返します。このため、融合した結果には、ベクトル検索に表示されるベクトル検索結果(両方に表示されるものを含む)が含まれます。スコア条件: `vector_score > 0`
`MINUS_TEXT`	ベクトル検索結果のすべての個別行から、テキスト検索結果とベクトル検索結果の両方に共通する行を引いたものを返します。このため、融合した結果には、ベクトル検索に表示されるベクトル検索結果(両方に表示されるものは除く)が含まれます。スコア条件: `text_score = 0`
`MINUS_VECTOR`	テキスト検索結果のすべての個別行から、テキスト検索結果とベクトル検索結果の両方に共通する行を引いたものを返します。このため、融合した結果には、テキスト検索に表示されるテキスト検索結果(両方に表示されるものは除く)が含まれます。スコア条件: `vector_score = 0`
`RERANK`	テキスト検索からすべての個別行を返し、それぞれのベクトルの集計ベクトル・スコアで順序付けされます。テキスト検索の後に集計されたドキュメント・ベクトル・スコアが使用されるため、このフィールドにはスコア条件はありません。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name"     : "my_hybrid_idx",
            "search_fusion"         : "UNION",
            "vector":
                    { "search_text" : "leadership experience" },
             "text":
                    { "contains"    : "C and Python" }
          }'))
FROM DUAL;

search_scorer

キーワード検索結果とセマンティック検索結果の両方から結合された「融合」検索スコアを評価する方法を指定します。

RSF (デフォルト): Relative Score Fusion (RSF)アルゴリズムを使用します。
RRF: Reciprocal Rank Fusion (RRF)アルゴリズムを使用します。

これらのアルゴリズムがハイブリッド検索モードでどのように機能するかをより深く理解するには、「ハイブリッド検索の理解」を参照してください。

次に例を示します。

ハイブリッド検索用の単一の検索テキスト文字列の場合:

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_text"       : "C, Python",
         "search_scorer"     : "rsf"
      }'))
FROM DUAL;

個別のベクトル検索文字列およびテキスト検索文字列の場合:

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_scorer"     : "rsf",
         "vector":
          { "search_text"    : "leadership experience" },
         "text":
          { "contains"       : "C and Python" }
      }'))
FROM DUAL;

ベクトル

ハイブリッド・ベクトル索引のベクトル索引部分に対するセマンティック検索の問合せパラメータを指定します:

search_text: 検索テキスト文字列(問合せテキスト)。

この文字列は問合せベクトル(埋込み)に変換され、VECTOR_DISTANCE問合せでベクトル化されたチャンク索引に対する検索に使用されます。

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "vector":
                    { "search_text" : "C, Python" }
          }'))
FROM DUAL;
```

search_vector: ベクトル埋込み(問合せベクトル)。

この埋込みは、ベクトル化されたチャンク索引を検索するためにVECTOR_DISTANCE問合せで直接使用されます。

ノート:

セマンティック問合せがすでにベクトルとして使用可能な場合、search_vectorは前述のsearch_textの代替となります。ここで渡すベクトル埋込みは、指定されたハイブリッド・ベクトル索引によるセマンティック検索に使用されるものと同じ埋込みモデルを使用して生成する必要があります。

次に例を示します。

SELECT JSON_SERIALIZE(
         DBMS_HYBRID_VECTOR.SEARCH(
            json_object( 'hybrid_index_name' value 'my_hybrid_idx',
                 'vector' value json_object( 'search_vector' value vector_serialize(
                                            vector_embedding(doc_model
                                                        using
                                                        'C, Python, Database'
                                                        as data)
                                                    RETURNING CLOB)
                                             RETURNING JSON)
                  RETURNING JSON))
           RETURNING CLOB PRETTY)
FROM dual;

search_mode: ハイブリッド・ベクトル索引に問い合せるためのドキュメント検索モードまたはチャンク検索モード:

パラメータ説明

パラメータ	説明
`DOCUMENT` (デフォルト)	ドキュメントレベルの結果を返します。ドキュメント・モードでは、検索の結果は、識別された最適なドキュメントのリストに対応する実表のドキュメントIDのリストです。
`CHUNK`	チャンクレベルの結果を返します。チャンク・モードでは、チャンクが同じドキュメントからのものか異なるドキュメントからのものかに関係なく、検索の結果は識別された最適なチャンクのリストに対応する実表からのチャンク識別子および関連付けられたドキュメントIDのリストになります。これらのチャンク・テキストからのコンテンツは、LLMの入力として使用して応答を形成できます。

DOCUMENT (デフォルト)

ドキュメントレベルの結果を返します。ドキュメント・モードでは、検索の結果は、識別された最適なドキュメントのリストに対応する実表のドキュメントIDのリストです。

CHUNK

チャンクレベルの結果を返します。チャンク・モードでは、チャンクが同じドキュメントからのものか異なるドキュメントからのものかに関係なく、検索の結果は識別された最適なチャンクのリストに対応する実表からのチャンク識別子および関連付けられたドキュメントIDのリストになります。

これらのチャンク・テキストからのコンテンツは、LLMの入力として使用して応答を形成できます。

チャンク・モードのセマンティック検索の例:

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "CHUNK"
          }
      }'))
FROM DUAL;

aggregator: DOCUMENT SEARCH_MODE内の各ドキュメントのベクトル・スコアをランク付けするために適用する集計関数。

パラメータ	説明
`MAX` (デフォルト)	結果スコアとして最上位のチャンク・スコアを選択する標準データベース集計関数。
`AVG`	チャンク・スコアを合計し、カウントで除算する標準データベース集計関数。
`MEDIAN`	ソートされたスコアの中間値または補間値を計算する標準データベース集計関数。
`BONUSMAX`	この関数は、最大のチャンク・スコアと、残りを他の最上位スコアの平均スコアと乗算したものを結合します。
`WINAVG`	この関数は、チャンク・スコアのローリング・ウィンドウ(サイズ`windowSize`)の最大平均を計算します。
`ADJBOOST`	この関数は、平均「ブースト」チャンク・スコアを計算します。チャンク・スコアは、`BOOSTFACTOR`に周囲のチャンク・スコア(存在する場合)の平均スコアを乗算して強調されます。
`MAXAVGMED`	この関数は、`MAX`、`AVGN`および`MEDN`値の重み付け合計を計算します。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "AVG"
          }
      }'))
FROM DUAL;

result_max: ベクトル索引からフェッチ(近似)する距離順のベクトル結果の最大数。

値: 0 (ゼロ)より大きい任意の正の整数

デフォルト: このフィールドが指定されていない場合、デフォルトでは、最大値はtopNに基づいて計算されます。

次に例を示します:

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5,
             "result_max"    : 100
          }
      }'))
FROM DUAL;

score_weight: セマンティックのVECTOR_DISTANCE問合せに割り当てる相対加重(重要度またはプリファレンス)。この値は、RSFランキングの結果を結合する場合に使用されます。

値: 0 (ゼロ)より大きい任意の正の整数

デフォルト: 10 (テキスト問合せよりもベクトル問合せの重要度が10倍高いことを意味します)

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5
          }
      }'))
FROM DUAL;
```
rank_penalty: ベクトル問合せに割り当てるペナルティ(1/(rank+penalty)として表されるRRFの分母)。これは、ドキュメント内の不要な単語や反復的な単語の重要性を減らすことで、関連性スコアのバランスをとるのに役立ちます。この値は、RRFランキングの結果を結合する場合に使用されます。

値: 0 (ゼロ)または任意の正の整数

デフォルト: 1

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_scorer"     : "rrf",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5,
             "rank_penalty"  : 2
          }
      }'))
FROM DUAL;
```
inpath: 有効なJSONパス

vector.inpathでは、ドキュメント内のベクトライザ・パスが使用されます。このパラメータを指定すると、このフィールドに指定されたパスに検索が制限されます。有効なJSON形式のパス($.a.b.c.d)の配列を受け入れます。

パスのリストはVECTORIZER索引のパス・リストと照合され、ベクトル索引検索に対する問合せ制約が形成されます。$.main.*など、パスの単純なワイルドカードがサポートされています。

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_scorer"     : "rrf",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5,
             "rank_penalty"  : 2,
             "inpath"   : ["$.person.*", "$.product.*"]
          }
      }'))
FROM DUAL;
```

accuracy: セマンティックVECTOR_DISTANCE問合せに割り当てるターゲットの精度。

値: 0 (ゼロ)から100までの任意の正の整数。

デフォルト: 0 (ゼロ)。値0は、vector_distance問合せの内部デフォルトがフィールドに割り当てられることを示します。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5,
             "rank_penalty"  : 2,
             "inpath"        : ["$.person.*", "$.product.*"],
             "accuracy"      : 95
          }
      }'))
FROM DUAL;

index_probes: セマンティックVECTOR_DISTANCE問合せに割り当てるプローブの数。

値: 0 (ゼロ).より大きい任意の正の整数

デフォルト: 0 (ゼロ)。値0は、プローブの内部デフォルト数がフィールドに割り当てられることを示します。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "vector":
          {
             "search_text"   : "leadership experience",
             "search_mode"   : "DOCUMENT",
             "aggregator"    : "MAX",
             "score_weight"  : 5,
             "rank_penalty"  : 2,
             "inpath"        : ["$.person.*", "$.product.*"],
             "accuracy"      : 95,
             "index_probes"  : 3
          }
      }'))
FROM DUAL;

index_efsearch: セマンティックVECTOR_DISTANCE問合せに割り当てるefs。

値: 0 (ゼロ).より大きい任意の正の整数値0は、vector_distance問合せの内部デフォルトがフィールドに割り当てられることを示します。

デフォルト: 0 (ゼロ)

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name"   : "my_hybrid_idx",
         "vector":
          {
             "search_text"     : "leadership experience",
             "search_mode"     : "DOCUMENT",
             "aggregator"      : "MAX",
             "score_weight"    : 5,
             "rank_penalty"    : 2,
             "inpath"          : ["$.person.*", "$.product.*"],
             "accuracy"        : 95,
             "index_probes"    : 3,
             "index_efsearch"  : 500,
          }
      }'))
FROM DUAL;

filter_type: ベクトル索引ヒント・フィルタのタイプ。ベクトル索引のオプティマイザ計画、ヒントおよびフィルタ・タイプの詳細は、「ベクトル索引のオプティマイザ計画」および「ベクトル索引のヒント」を参照してください。
値: filter_typeフィールドには、次のいずれかの値を指定できます:
- PRE_W - 後戻り結合ありの事前フィルタ。これはHNSW索引にのみ適用されます。
- PRE_WO - 後戻り結合なしの事前フィルタ。これは、HNSW索引とIVF索引の両方に適用されます。
- IN_W - 後戻り結合ありのインフィルタ。これはHNSW索引にのみ適用されます。
- IN_WO - 後戻り結合なしのインフィルタ。これはHNSW索引にのみ適用されます。
- POST_WO - 後戻り結合なしの後フィルタ。これはIVF索引にのみ適用されます。
デフォルト: フィルタ・タイプのヒントなし。

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name"   : "my_hybrid_idx",
         "vector":
          {
             "search_text"     : "leadership experience",
             "search_mode"     : "DOCUMENT",
             "aggregator"      : "MAX",
             "score_weight"    : 5,
             "rank_penalty"    : 2,
             "inpath"          : ["$.person.*", "$.product.*"],
             "accuracy"        : 95,
             "index_probes"    : 3,
             "index_efsearch"  : 500,
             "filter_type"     : "IN_WO"
          }
      }'))
FROM DUAL;
```

text

ハイブリッド・ベクトル索引のOracle Text索引部分に対するキーワード検索の問合せパラメータを指定します。

contains: 検索テキスト文字列(問合せテキスト)。

この文字列は、キーワード検索用のOracle TextのCONTAINS問合せ演算子の構文に変換されます。

CONTAINS問合せ演算子を使用すると、OR (|)、AND (&)、STEM ($)、MINUS (-)などの全文検索の問合せ式を指定できます。使用するすべての演算子の完全なリストは、『Oracle Textリファレンス』を参照してください。

次に例を示します。

テキストに純粋なキーワード検索用の文字列が含まれる場合:
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "text":
                   { "contains" : "C and Python" }
          }'))
FROM DUAL;
```
ハイブリッド検索にvectorおよびtextサブ要素を使用する個別の検索テキストの場合。1つの検索テキストまたはベクトル埋込みでセマンティック検索のVECTOR_DISTANCE問合せを実行します。2番目の検索テキストでキーワード検索のCONTAINS問合せを実行します。この問合せでは、キーワード・スコアとセマンティック・スコアを組み合せた2つの個別のキーワード問合せとセマンティック問合せが実行されます。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "vector":
                    { "search_text" : "leadership experience" },
             "text":
                    { "contains" : "C and Python" }
          }'))
FROM DUAL;
```

search_text: contains問合せを自動的に作成するために使用する代替検索テキスト。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "text":
                   { "contains"    : "C and Python",
                     "search_text" : "data science skills"
                   }
          }'))
FROM DUAL;

json_textcontains: containsおよびsearch_textのかわりに使用する代替のJSON式。

ノート:

json_textcontains WITHにtext.containsまたはtext.search_textのいずれかを指定するとエラーになります。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "text":
                   { "json_textcontains"    : ["$.person", "$C and $Python"]
                   }
          }'))
FROM DUAL;

score_weight: テキストのCONTAINS問合せに割り当てる相対的な重み(重要度またはプリファレンスの程度)。この値は、RSFランキングの結果を結合する場合に使用されます。

値: 0 (ゼロ)より大きい任意の正の整数

デフォルト: 1 (ニュートラル加重を意味します)

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "text":
          {
             "contains"      : "C and Python",
             "score_weight"  : 1
          }
      }'))
FROM DUAL;
```
rank_penalty: キーワード問合せに割り当てるペナルティ(1/(rank+penalty)として表されるRRFの分母)。

これは、ドキュメント内の不要な単語や反復的な単語の重要性を減らすことで、関連性スコアのバランスをとるのに役立ちます。この値は、RRFランキングの結果を結合する場合に使用されます。

値: 0 (ゼロ)または任意の正の整数

デフォルト: 5

次に例を示します。
```
SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "text":
          {
             "contains"      : "C and Python",
             "rank_penalty"  : 5
          }
      }'))
FROM DUAL;
```

inpath: 有効なJSONパス

このパラメータを指定すると、このフィールドに指定されたパスに検索が制限されます。有効なJSON形式のパス($.a.b.c.d)の配列を受け入れます。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "text":
          {
             "contains"      : "C and Python",
             "rank_penalty"  : 5,
             "inpath"   : ["$.person.*","$.product.*"]
          }
      }'))
FROM DUAL;

result_max: ドキュメント索引から取得するドキュメント結果(スコア順)の最大数。指定しない場合、最大値はtopNに基づいて計算されます。

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "text":
          {
             "contains"      : "C and Python",
             "rank_penalty"  : 5,
             "inpath"        : ["$.person.*","$.product.*"],
             "result_max"    : 100
          }
      }'))
FROM DUAL;

filter_by

標準のリレーショナル論理制約を使用して検索結果を制約するには:

パラメータ値

op

論理比較演算子。許容される値 - 次の演算子のいずれか:

単純な比較演算子: '<'、'>'、'<='、'>='、'='、'!='、'^='、'<>'、'LIKE'、'LIKEC'、'LIKE2'、'LIKE4'、'INSTR'、'INSTR2'、'INSTR4','INSTRB'、'INSTRC'、'STSTR'、'STSTR2'、'STSTR4','STSTRB'、'STSTRC'、'REGEXP_LIKE'、'BETWEEN'、'EXISTS'

ノート:
STSTRは、リスト内の唯一の標準ではない演算子です。これは「START STRING」を表し、INSTRと似ていますが、結果は位置1と等しい必要があります。
グループ比較演算子 :
- '<'、'>'、'<='、'>='、'='、'!='とANY、SOME、ALLの18通りの組合せ
- IN
論理演算子: 'AND'、'OR'、'NOT'、'NOTAND'、'NOTOR'

ノート:
"NOTAND" and "NOTOR"は、次の式の短縮形であり、JSON式ツリーの削減に役立ちます。NOTORはNOT (arg1 OR arg2 ...)です。NOTANDはNOT (arg1 AND arg2 ...)です

col

実表の列名。

ノート:

論理演算子にはcolumnは必要ありません。
同じ要素にはcolまたはpathのいずれかのみを指定できます。

path

実表のJSON列内のJSONパスのドット表記。

ノート:

論理演算子にはpathは必要ありません。
同じ要素にはcolまたはpathのいずれかのみを指定できます。
実表にdataというJSON列がある場合、構文は"data.path"となり、パスはJSONデータ・スキーマの照合で大/小文字が区別されます。詳細は、JSONのドット表記法を参照してください。

type

列のデータ型。使用可能な型: number、date、timestampおよびstring。

func

比較演算子の場合、比較の前にオプションの関数を列値に適用できます。これらの関数は標準のSQL関数です。1つの例外として、完全な名前"TO_BINARY_DOUBLE"の別名として"TO_DOUBLE"が提供されています

使用可能な値: ABS、FLOOR、LENGTH、CEILING、UPPER、LOWER、TO_BOOLEAN、TO_DATE、TO_DOUBLE、TO_BINARY_DOUBLE、TO_NUMBER、TO_CHAR、TO_TIMESTAMP。

args

演算子への引数の配列:

単純な比較演算子の場合、argsには1つのリテラル値が含まれます。0個または複数の引数を指定するとエラーになります。
グループ比較演算子の場合、argsには1つ以上のリテラル値が含まれます。引数が0個の場合はエラーになります。
論理演算子の場合、argsには同じ構造のサブ要素が含まれ、式ツリーを形成します。

例: 単純な比較演算子の使用

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "filter_by":
                    { "op"   : "<",
                      "col"  : "price",
                      "type" : "number",
                      "func" : "ABS"
                      "args" : ["10"] }
          }'))
FROM DUAL;

例: グループ比較演算子の使用

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "filter_by":
                    { "op"   :  "IN",
                      "path" : "DATA.brand",
                      "type" " "string",
                      "args" : ["nike", "adidas"] }
          }'))
FROM DUAL;

例: 論理演算子の使用

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json('{ "hybrid_index_name" : "my_hybrid_idx",
            "filter_by":
                    { "op"   :  "AND",
                      "args" : [
                      {"op" : "IN", "col" : "brand", "type" : "string", "args" : ["nike", "adidas"]},
                      {"op" : "<", "col" : "price", "type" : "number", "args" : ["10"]}]
                    }
          }'))
FROM DUAL;

return

結果セットに表示するフィールドを指定します:

パラメータ説明

パラメータ	説明
`topN`	返される最も一致する結果の最大数値: `0` (ゼロ)より大きい任意の整数デフォルト: `20`
`values`	検索結果の戻り属性スコアの値の範囲は100 (最高)から0 (最低)です。 `rowid`: ソース・ドキュメントに関連付けられた行ID。 `score`: キーワード検索およびセマンティック検索のスコアから計算された最終スコア。 `vector_score`: ベクトル検索結果のセマンティック・スコア。 `text_score`: テキスト検索結果のキーワード・スコア。 `vector_rank`: セマンティック(`VECTOR_DISTANCE`)検索から取得されたチャンクのランキング。 `text_rank`: キーワード(`CONTAINS`)検索から取得されたドキュメントのランキング。 `chunk_text`: 各チャンクの判読可能なコンテンツ `chunk_id`: 各チャンク・テキストのID `paths`: 結果が発生したパス。デフォルト: `paths`以外の前述のすべてのリターン属性がデフォルトで示されます。JSON以外のパスがないため、`paths`フィールドを明示的に指定する必要があります。
`format`	結果の形式: `JSON` (デフォルト) `XML`

topN

返される最も一致する結果の最大数

値: 0 (ゼロ)より大きい任意の整数

デフォルト: 20

values

検索結果の戻り属性スコアの値の範囲は100 (最高)から0 (最低)です。

rowid: ソース・ドキュメントに関連付けられた行ID。
score: キーワード検索およびセマンティック検索のスコアから計算された最終スコア。
vector_score: ベクトル検索結果のセマンティック・スコア。
text_score: テキスト検索結果のキーワード・スコア。
vector_rank: セマンティック(VECTOR_DISTANCE)検索から取得されたチャンクのランキング。
text_rank: キーワード(CONTAINS)検索から取得されたドキュメントのランキング。
chunk_text: 各チャンクの判読可能なコンテンツ
chunk_id: 各チャンク・テキストのID
paths: 結果が発生したパス。

デフォルト: paths以外の前述のすべてのリターン属性がデフォルトで示されます。JSON以外のパスがないため、pathsフィールドを明示的に指定する必要があります。

format

結果の形式:

JSON (デフォルト)
XML

次に例を示します。

SELECT DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_text"       : "C, Python",
         "return":
          {
             "values"        : [ "rowid", "score", "paths" ],
             "topN"          : 3,
             "format"        : "JSON"
          }
      }'))
FROM DUAL;

すべての問合せパラメータを使用した完全な例

次の例は、my_hybrid_idxに対して個別にテキスト検索およびベクトル検索を実行するハイブリッド検索問合せを示しています。この問合せでは、vector_distance関数を使用したベクトル検索のsearch_textとして「prioritize teamwork and leadership experience」、およびcontains演算子を使用したテキスト検索のキーワードとして「C and Python」を指定しています。検索モードはDOCUMENTで、検索結果をtopN件のドキュメントとして返します。

SELECT JSON_SERIALIZE(
  DBMS_HYBRID_VECTOR.SEARCH(
    json(
      '{ "hybrid_index_name" : "my_hybrid_idx",
         "search_fusion"     : "INTERSECT",
         "search_scorer"     : "rsf",
         "vector":
          {
             "search_text"   : "prioritize teamwork and leadership experience",
             "search_mode"   : "DOCUMENT",
             "score_weight"  : 10,
             "rank_penalty"  : 1,
             "aggregator"    : "MAX",
             "inpath"        : ["$.main.body", "$.main.summary"],
             "accuracy"      : 95
          },
         "text":
          {
             "contains"      : "C and Python",
             "score_weight"  : 1,
             "rank_penalty"  : 5,
             "inpath"        : ["$.main.body"]
          },
         "return":
          {
             "format"        : "JSON",
             "topN"          : 3,
             "values"        : [ "rowid", "score", "vector_score",
                                 "text_score", "vector_rank",
                                 "text_rank", "chunk_text", "chunk_id", "paths" ]
          }
      }'
    )
  ) pretty)
FROM DUAL;

上位3行は関連性順に並べられ、スコアが高いほど一致していることを示します。デフォルトでは、すべての戻り属性が表示されます:

[
  {
    "rowid"         : "AAAR9jAABAAAQeaAAA",
    "score"         : 58.64,
    "vector_score"  : 61,
    "text_score"    : 35,
    "vector_rank"   : 1,
    "text_rank"     : 2,
    "chunk_text"    : "Candidate 1: C Master. Optimizes low-level system (i.e. Database)
                       performance with C. Strong leadership skills in guiding teams to 
                       deliver complex projects.",
    "chunk_id"      : "1",
    "paths"         : ["$.main.body","$.main.summary"]
  },
  {
    "rowid"         : "AAAR9jAABAAAQeaAAB",
    "score"         : 56.86,
    "vector_score"  : 55.75,
    "text_score"    : 68,
    "vector_rank"   : 3,
    "text_rank"     : 1,
    "chunk_text"    : "Candidate 3: Full-Stack Developer. Skilled in Database, C, HTML,
                       JavaScript, and Python with experience in building responsive web 
                       applications. Thrives in collaborative team environments.",
    "chunk_id"      : "1",  
    "paths"         : ["$.main.body", "$.main.summary"]
  },
  {
    "rowid"         : "AAAR9jAABAAAQeaAAD",
    "score"         : 51.67,
    "vector_score"  : 56.64,
    "text_score"    : 2,
    "vector_rank"   : 2,
    "text_rank"     : 3,
    "chunk_text"    : "Candidate 2: Database Administrator (DBA). Maintains and secures
                       enterprise database (Oracle, MySql, SQL Server). Passionate about 
                       data integrity and optimization. Strong mentor for junior DBA(s).",
    "chunk_id"      : "1",
    "paths"         : ["$.main.body", "$.main.summary"]
  }
]

エンドツーエンドの例:

ハイブリッド・ベクトル索引を作成し、索引に対するすべてのタイプの問合せを調べる方法については、「ハイブリッド・ベクトル索引のエンドツーエンドの問合せの例」を参照してください。