注: 以下の翻訳の正確性は検証されていません。AIPを利用して英語版の原文から機械的に翻訳されたものです。

Java オントロジー SDK

このページでは、Restaurant オブジェクトとそれに関連するアクションおよびクエリを例に、Java オントロジー SDK の汎用的なドキュメントを提供します。プラットフォームの Developer Console を使用して、お使いのオントロジーに基づいたドキュメントを生成できます。

プロパティ	API名	データ型
レストランID（主キー）	`restaurantId`	文字列
レストラン名（タイトル）	`restaurantName`	文字列
住所	`address`	文字列
メール	`eMail`	文字列
レビュー数	`numberOfReviews`	Integer
電話番号	`phoneNumber`	文字列
レビュー概要	`reviewSummary`	文字列
開店日	`dateOfOpening`	LocalDate

単一の `Restaurant` を読み込む

パラメーター：

primaryKey string：取得する Restaurant の主キークエリの例：

Copied!1
Restaurant result = client.ontology().objects().Restaurant().fetch("primaryKey").orElseThrow();

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
    "__primaryKey": "Restaurant Id",
    "eMail": "E Mail",
    "restaurantId": "Restaurant Id",
    "address": "Address",
    "reviewSummary": "Review Summary",
    "phoneNumber": "Phone Number",
    "numberOfReviews": 123,
    "restaurantName": "Restaurant Name"
}

`Restaurants` のストリームを読み込む

コレクションにまとめられるオブジェクトのストリームを読み込みます。ユーザーがストリームから取得するオブジェクト数に応じて、オブジェクトのページが自動的に読み込まれます。

このエンドポイントは、オブジェクトタイプで使用される基盤のオブジェクト同期技術を利用します。Restaurant が Object Storage v2 を使用している場合、リクエストに制限はありません。Restaurant が Object Storage v1 (Phonograph) を使用している場合、結果は10,000件に制限されます。10,000個を超える Restaurants がリクエストされた場合、ObjectsExceededLimit エラーがスローされます。

クエリの例：

Copied!1
Stream<Restaurant> result = client.ontology().objects().Restaurant().fetchStream()

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "eMail": "E Mail",
            "restaurantId": "Restaurant Id",
            "address": "Address",
            "reviewSummary": "Review Summary",
            "phoneNumber": "Phone Number",
            "numberOfReviews": 123,
            "restaurantName": "Restaurant Name"
        }
        // ... ページの残り
    ]
}

すべての `Restaurants` を読み込む

すべての Restaurant オブジェクトをリストに読み込みます。

クエリの例：

Copied!1
List<Restaurant> result = client.ontology().objects().Restaurant().fetchStream().toList()

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "eMail": "E Mail",
            "restaurantId": "Restaurant Id",
            "address": "Address",
            "reviewSummary": "Review Summary",
            "phoneNumber": "Phone Number",
            "numberOfReviews": 123,
            "restaurantName": "Restaurant Name"
        }
        // ... データの残り
    ]
}

取得オプション

Java オントロジー SDK では、単一オブジェクトとストリームのオプションに FetchRequest を使用し、手動ページネーションのオプションに FetchPageRequest を使用します。

設定	サポートされるメソッド	説明
`FetchRequest.includeRids()`	`fetch()`, `fetchStream()`	オブジェクトの RID を含めます。デフォルト値は `false` です。
`FetchRequest.loadPropertySecurityMetadata()`	`fetch()`, `fetchStream()`	プロパティレベルのセキュリティメタデータを含めます。デフォルト値は `false` です。
`FetchRequest.includeAllBaseObjectProperties()`	インターフェースの `fetchStream()`	インターフェースオブジェクトセットを読み取る際に、基になる具象オブジェクトタイプのすべてのプロパティを含めます。この設定はオブジェクトタイプのクエリには効果がありません。
`FetchPageRequest.pageSize()`	`fetchPage()`	ページ内のリクエストするオブジェクト数を設定します。デフォルト値は `1,000` です。
`FetchPageRequest.pageToken()`	`fetchPage()`	前の `Page` のページトークンを渡して、次のページを読み込みます。
`FetchPageRequest.includeRids()`	`fetchPage()`	各オブジェクトの RID を含めます。デフォルト値は `false` です。
`FetchPageRequest.loadPropertySecurityMetadata()`	`fetchPage()`	プロパティレベルのセキュリティメタデータを含めます。デフォルト値は `false` です。

たとえば、次のリクエストは、1個のオブジェクトを読み込む際に RID とプロパティのセキュリティメタデータを含めます。

Copied!1
2
3
4
5
6
7
8
9
10
11
FetchRequest<Restaurant.ObjectProperty> request =
    FetchRequest.<Restaurant.ObjectProperty>builder()
        .includeRids(true)
        .loadPropertySecurityMetadata(true)
        .build();

Restaurant restaurant = client.ontology()
    .objects()
    .Restaurant()
    .fetch("primaryKey", request)
    .orElseThrow();

FetchRequest は selectedProperties フィールドを定義していますが、現在、生成された Java オントロジー SDK の読み取りメソッドは、このフィールドをリクエストに適用しません。そのため、プロパティレベルの選択は現在サポートされていません。

並べ替えた結果を読み込む

特定のプロパティの並べ替え方向を指定して、並べ替えた Restaurants のリストを読み込みます。API 経由で呼び出す場合、並べ替え条件は fields 配列で指定します。SDK 経由で呼び出す場合、複数の orderBy 呼び出しを連結できます。文字列の並べ替え順序では大文字と小文字が区別され、数字、大文字、小文字の順になります。たとえば、Cat は bat より前になります。

パラメーター：

ordering {ObjectType}Ordering：並べ替えの基準にするプロパティ。Java SDK では、{ObjectType}Ordering インターフェースを通じて指定できます。
プロパティ名と方向 ASC| DESC：並べ替える方向（昇順または降順）。Java SDK では、{ObjectType}Ordering インターフェースの {PROPERTY_NAME}_ASC および {PROPERTY_NAME}_DESC 修飾子を通じて指定できます。

クエリの例：

Copied!1
2
3
4
5
Stream<Restaurant> result = client.ontology()
    .objects()
    .Restaurant()
    .orderBy(RestaurantOrdering.RESTAURANT_NAME_ASC)
    .fetchStream();

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Object A",
            "restaurantName": "A"
            // ...残りのプロパティ
        },
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Object B",
            "restaurantName": "B"
            // ...残りのプロパティ
        }
        // ...ページの残り
    ]
}

フィルタリング

実行できるフィルタリングの種類は、オブジェクトタイプのプロパティのデータ型によって異なります。これらのフィルターをブール式で組み合わせて、より複雑なフィルターを構成することもできます。

このエンドポイントは、オブジェクトタイプに使用されている基盤のオブジェクト同期技術を利用します。Restaurant が Object Storage v2 を使用している場合、リクエストの制限はありません。Restaurant が Object Storage v1 (Phonograph) を使用している場合、結果は10,000件に制限されます。10,000件を超える Restaurants がリクエストされた場合、ObjectsExceededLimit エラーがスローされます。

パラメーター：

where Filter（任意）：特定のプロパティで絞り込みます。使用できる操作は、プロパティのデータ型によって異なります。これは、各プロパティに対して呼び出すメソッドを持つ {ObjectType}Filter で表されます。
orderBy OrderBy（任意）：特定のプロパティに基づいて結果を並べ替えます。SDK を使用する場合、.where 呼び出しに orderBy 呼び出しを連結して、同じ結果を得ることができます。これは、各プロパティに対して呼び出すメソッドを持つ {ObjectType}OrderBy で表されます。

クエリの例：

Copied!1
2
3
4
5
6
List<Restaurant> result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().isNull(false))
    .fetchStream()
    .toList();

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": null
            // ... 残りのプロパティ
        }
        // ... ページの残り
    ]
}

検索フィルターの種類（`RestaurantFilter`）

指定した値で始まる

文字列プロパティにのみ適用されます。restaurantName が指定された文字列で始まる Restaurants を検索します（大文字と小文字は区別しません）。

パラメーター：

field method：使用するプロパティの名前（例: restaurantName）。
value string：Restaurant Name との接頭辞の照合に使用する値。たとえば、「foo」は「foobar」に一致しますが、「barfoo」には一致しません。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().startsWith("foo"));

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "foobar"
            // ... 残りのプロパティ
        }
    ]
}

いずれかの語句を含む

文字列プロパティにのみ適用されます。指定された値に含まれる、空白で区切られた単語のいずれかが、任意の順序で restaurantName に含まれる Restaurants を返します（大文字と小文字は区別しません）。

パラメーター：

field method：使用するプロパティの名前（例: restaurantName）。
value string：照合する、空白で区切られた単語。たとえば、「foo bar」は「bar baz」に一致しますが、「baz qux」には一致しません。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().containsAnyTerm("foo bar"));

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "foo bar baz"
            // ... 残りのプロパティ
        },
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000001",
            "restaurantName": "bar baz"
            // ... 残りのプロパティ
        }
    ]
}

すべての語句を含む

文字列プロパティにのみ適用されます。指定された値に含まれる、空白で区切られた単語のすべてが、任意の順序で restaurantName に含まれる Restaurants を返します（大文字と小文字は区別しません）。

パラメーター：

field method：使用するプロパティの名前（例：restaurantName）。
value string：照合する、空白で区切られた単語。たとえば、「foo bar」は「hello foo baz bar」に一致しますが、「foo qux」には一致しません。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().containsAllTerms("foo bar"));

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "hello foo baz bar"
            // ... 残りのプロパティ
        }
    ]
}

すべての語句を順序どおりに含む

文字列プロパティにのみ適用されます。指定された順序ですべての語句が restaurantName に含まれる Restaurants を返します（大文字と小文字は区別しません）。ただし、語句は互いに隣接している必要があります。

パラメーター：

field method：使用するプロパティの名前（例：restaurantName）。
value string：照合する、空白で区切られた単語。たとえば、「foo bar」は「hello foo bar baz」に一致しますが、「bar foo qux」には一致しません。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().containsAllTermsInOrder("foo bar"));

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "foo bar baz"
            // ... 残りのプロパティ
        }
    ]
}

範囲比較

数値、文字列、DateTime プロパティにのみ適用されます。Restaurant.restaurantName が指定された値より小さい Restaurants を返します。

パラメーター：

field method：使用するプロパティの名前（例：restaurantName）。
value string：Restaurant Name と比較する値

比較の種類：

より小さい lt
より大きい gt
以下 lte
以上 gte

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().lt("Restaurant Name"));

等しい

ブール値、DateTime、数値、文字列プロパティにのみ適用されます。restaurantName が指定された値と等しい Restaurants を検索します。

パラメーター：

field method：使用するプロパティの名前（例：restaurantName）。
value string：Restaurant Name との等価性チェックに使用する値。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().eq("Restaurant Name"));

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "Restaurant Name"
            // ... 残りのプロパティ
        }
    ]
}

null チェック

Array、ブール値、DateTime、数値、文字列プロパティにのみ適用されます。restaurantName の値が存在するかどうかに基づいて Restaurants を検索します。

パラメーター：

field method：使用するプロパティの名前（例：restaurantName）。
value boolean：Restaurant Name が存在するかどうか。TypeScript SDK では、フィールドが null でないことを確認するには not フィルターを使用する必要があります。

クエリの例：

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().isNull(true));

`Not` フィルター

クエリの条件を満たさない Restaurants を返します。ほかのブールフィルター操作とさらに組み合わせることもできます。

パラメーター：

value Filter：反転する検索クエリ。

クエリの例：

Copied!1
2
3
4
5
6
7
8
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(
        RestaurantFilter.$not(
            RestaurantFilter.restaurantName().isNull(true)
        )
    );

`And` フィルター

すべてのクエリの条件を満たす Restaurants を返します。ほかのブールフィルター操作とさらに組み合わせることもできます。

パラメーター：

value Filter[]：and で結合する検索クエリ。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(
        RestaurantFilter.$and(
            RestaurantFilter.restaurantName().isNull(false),
            RestaurantFilter.restaurantName().eq("<primarykey>")
        )
    );

`Or` フィルター

指定されたクエリのいずれかの条件を満たす Restaurants を返します。ほかのブールフィルター操作とさらに組み合わせることもできます。

パラメーター：

value Filter[]：or で結合する検索クエリ。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(
        RestaurantFilter.$or(
            RestaurantFilter.restaurantName().isNull(false),
            RestaurantFilter.restaurantName().eq("<primarykey>")
        )
    );

集計

集計を使用すると、データの概要統計を計算できます。個々のデータポイントを手動で分析することなく、大規模なデータセットからパターンやインサイトを把握するのに役立ちます。複数の集計操作を組み合わせて、データに関するより深いインサイトを得られる、より複雑なクエリを作成できます。

このエンドポイントは、オブジェクトタイプで使用されている基盤のオブジェクト同期技術を利用します。Restaurant が Object Storage v2 を使用している場合、リクエストの上限はありません。Restaurant が Object Storage v1（Phonograph）を使用している場合、結果の上限は10,000件です。10,000個を超える Restaurants がリクエストされた場合、ObjectsExceededLimit エラーがスローされます。

Restaurants に対して集計を実行します。

パラメーター：

aggregation Aggregation[]（任意）：実行する集計関数。SDK では、.where を使用して集計計算と追加の検索を連結できます。
groupBy GroupBy[]（任意）：集計結果に対して作成するグループ化。
where Filter（任意）：特定のプロパティに対するフィルター。使用できる操作は、プロパティのデータ型によって異なります。

クエリの例：

Copied!1
2
3
4
5
6
7
AggregationResponse numRestaurants = client.ontology()
        .objects()
        .Restaurants()
        .where(RestaurantFilter.restaurantName().isNull(false))
        .groupBy(GroupBy.exact(Restaurant.Property.restaurantName()))
        .count()
        .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {
            "restaurantName": "Restaurant Name"
        },
        metrics: [
            {
                name: "count",
                value: 100
            }
        ]
    }]
}

集計の種類（`Aggregation`）

近似ユニーク値数

restaurantName のユニーク値の近似件数を計算します。

パラメーター：

field Property：使用するプロパティの名前（例：restaurantName）。
name string（任意）：計算された件数のエイリアス。デフォルトは distinctCount です。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Double distinctRestaurants = client.ontology()
        .objects()
        .Restaurant()
        .approximateDistinct(Restaurant.Property.restaurantName())
        .compute();

// これは上記と同等ですが、メトリクス名としてデフォルトの "distinctCount" の代わりに metricName を使用します。

AggregationResponse distinctRestaurants = client.ontology()
        .objects()
        .Restaurant()
        .aggregate(
            Map.of(
                "metricName",
                Aggregation.approximateDistinct(Restaurant.Property.restaurantName())
            )
        )
        .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {},
        metrics: [
            {
                name: "distinctCount",
                value: 100
            }
        ]
    }]
}

件数

Restaurants の総件数を計算します。

パラメーター：

name string（任意）：計算された件数のエイリアス。デフォルトは count です。

クエリの例：

Copied!1
2
3
4
5
Double distinctRestaurants = client.ontology()
        .objects()
        .Restaurant()
        .count()
        .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {},
        metrics: [
            {
                name: "count",
                value: 100
            }
        ]
    }]
}

数値集計

数値型のプロパティにのみ適用されます。Restaurants の数値型のプロパティの最大値、最小値、合計、または平均を計算します。

パラメーター：

field NumericProperty：使用するプロパティの名前（例：numberOfReviews）。
name string（任意）：計算された値のエイリアス。

集計の種類：

平均：avg()
最大値：max()
最小値：min()
合計：sum()

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Double avgReviewScore = client.ontology()
        .objects()
        .Restaurant()
        .avg(Restaurant.Property.numberOfReviews())
        .compute();

// これは上記と同等ですが、メトリクス名としてデフォルトの "avg" の代わりに avgReview を使用します。

AggregationResponse distinctRestaurants = client.ontology()
        .objects()
        .Restaurant()
        .aggregate(
            Map.of(
                "avgReview",
                Aggregation.avg(Restaurant.Property.numberOfReviews())
            )
        )
        .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {},
        metrics: [
            {
                name: "avg",
                value: 100
            }
        ]
    }]
}

グループ化の種類（`GroupBy`）

完全一致によるグループ化

restaurantName の値の完全一致で Restaurants をグループ化します。

パラメーター：

field Property：使用するプロパティの名前（例：restaurantName）。
maxGroupCount integer（任意）：作成する restaurantName のグループの最大数。

クエリの例：

Copied!1
2
3
4
5
6
AggregationResponse groupedRestaurants = client.ontology()
       .objects()
       .Restaurant()
       .groupBy(GroupBy.exact(Restaurant.Property.restaurantName()))
       .count()
       .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {
            "restaurantName": "Restaurant Name"
        },
        metrics: [
            {
                name: "count",
                value: 100
            }
        ]
    }]
}

数値バケット化

numberOfReviews を指定された幅のバケットに分割して、Restaurants をグループ化します。

パラメーター：

field NumericProperty：使用するプロパティの名前（例：numberOfReviews）。
fixedWidth integer（任意）：選択したプロパティを分割する各バケットの幅。

クエリの例：

Copied!1
2
3
4
5
6
AggregationResponse groupedRestaurants = client.ontology()
       .objects()
       .Restaurant()
       .groupBy(GroupBy.fixedWidth(Restaurant.Property.numberOfReviews(), 10))
       .count()
       .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {
            "restaurantName": "Restaurant Name"
        },
        metrics: [
            {
                name: "count",
                value: 100
            }
        ]
    }]
}

範囲によるグループ化

numberOfReviews の指定された範囲で Restaurants をグループ化します。

パラメーター：

field NumericProperty | DateProperty | TimestampProperty：使用するプロパティの名前（例：numberOfReviews）。
ranges AggregationRange[]（任意）：開始値を含み、終了値を含まない範囲。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
AggregationResponse groupedRestaurants = client.ontology()
    .objects()
    .Restaurant()
    .groupBy(
        GroupBy.range(
            Restaurant.Property.numberOfReviews(),
            List.of(
                AggregationRange.of(0, 3),
                AggregationRange.of(3, 5)
            )
        )
    )
    .count()
    .compute();

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{
    "excludedItems": 0,
    "data": [
        {
            "group": {
                "numberOfReviews": {
                    "startValue": 0,
                    "endValue": 3
                }
            },
            "metrics": [
                {
                    "name": "count",
                    "value": 50
                }
            ]
        },
        {
            "group": {
                "numberOfReviews": {
                    "startValue": 3,
                    "endValue": 5
                }
            },
            "metrics": [
                {
                    "name": "count",
                    "value": 30
                }
            ]
        }
    ]
}

日時によるグループ化

特定の日時の期間を持つバケットを使用して、dateOfOpening で Restaurants をグループ化します。

パラメーター：

field DateProperty | TimestampProperty：使用するプロパティの名前（例：dateOfOpening）。
value integer（任意）：グループ化する期間の単位数。

期間の種類：

秒 bySeconds()
分 byMinutes()
時間 byHours()
日 byDays()
週 byWeeks()
月 byMonths()
四半期 byQuarters()
年 byYears()

クエリの例：

Copied!1
2
3
4
5
6
AggregationResponse groupedRestaurants = client.ontology()
       .objects()
       .Restaurant()
       .groupBy(GroupBy.byDays(Restaurant.Property.dateOfOpening(), 10))
       .count()
       .compute();

API レスポンスの例：

{
    excludedItems: 0,
    data: [{
        group: {
            "dateOfOpening": {
                startValue: "2024-09-25"
            }
        },
        metrics: [
            {
                name: "count",
                value: 100
            }
        ]
    }]
}

オントロジーに対するアクション

オントロジーのアクションタイプは、データモデル内のオブジェクトに対して実行できる、事前定義された操作を指します。これらのアクションでは、オントロジー内のオブジェクトを作成、変更、削除できます。アクションタイプはオントロジーに基づいて生成され、Java オントロジー SDK 内で使用して、コード内のオブジェクトに対して特定のタスクを実行できます。

`Restaurant` にレビューを追加するためのパラメーター（`AddRestaurantReview`）

プロパティ	API名	データ型
レストランID	`restaurantId`	文字列
レビュー評価	`reviewRating`	Integer
レビュー概要	`reviewSummary`	文字列

アクションを適用する

アクションを適用するには、入力パラメーターの値を入力します。これによりアクションが実行され、レスポンスが有効か無効かが返されます。

パラメーター：

parameters Object：パラメーターIDから、その入力パラメーターに使用する値へのマップ。
- restaurantId string
- reviewRating integer
- reviewSummary string
options integer（任意）：グループ化する期間の単位数。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
AddReviewActionResponse response = client.ontology()
    .actions()
    .addReview()
    .apply(
        AddReviewActionRequest.builder()
            .restaurantId(restaurantId)
            .reviewRating(5)
            .reviewSummary("It was great!")
            .build(),
        ReturnEditsMode.ALL
    );

response.getValidationResult().accept(new ActionValidationVisitor<Object>() {
    @Override
    public Object valid(ActionValidationResponse response) {
        System.out.println("Review added successfully " + response);
        return null;
    }

    @Override
    public Object invalid(ActionValidationResponse response) {
        System.out.println("Review validation failed! " + response);
        return null;
    }
});

API レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
{
    "validation": {
        "result": "VALID",
        "submissionCriteria": [],
        "parameters": {
            "restaurantId": {
                "result": "VALID",
                "evaluatedConstraints": [],
                "required": true
            },
            "reviewRating": {
                "result": "VALID",
                "evaluatedConstraints": [],
                "required": true
            },
            "reviewSummary": {
                "result": "VALID",
                "evaluatedConstraints": [],
                "required": true
            }
        }
    },
    "edits": {
        "type": "edits",
        "edits": [
            {
                "type": "modifyObject",
                "primaryKey": "restaurantId1",
                "objectType": "Restaurant"
            }
        ],
        "addedObjectCount": 0,
        "modifiedObjectsCount": 1,
        "deletedObjectsCount": 0,
        "addedLinksCount": 0,
        "deletedLinksCount": 0
    }
}

バッチアクションを適用する

アクションのバッチを適用するには、入力パラメーターの値を入力します。これにより一連のアクションが実行され、レスポンスが有効か無効かが返されます。レスポンスには編集内容のみが含まれ、検証結果は含まれません。バッチの適用は、すべて適用されるか、まったく適用されないかのいずれかです。バッチ内のいずれかのアクションが失敗した場合、バッチ内の編集内容はどれも適用されません。

パラメーター：

parameters Object：パラメーターIDから、その入力パラメーターに使用する値へのマップ。
- restaurantId string
- reviewRating integer
- reviewSummary string
value ReturnEditsMode.(ALL|NONE)（任意）：アクションの適用後に、レスポンスで編集内容を返すかどうか。

クエリの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
AddReviewBatchActionResponse response = client.ontology()
    .actions()
    .addReview()
    .applyBatch(
        List.of(
            AddReviewActionRequest.builder()
                .restaurantId("restaurantId1")
                .reviewRating(5)
                .reviewSummary("It was great!")
                .build(),
            AddReviewActionRequest.builder()
                .restaurantId("restaurantId2")
                .reviewRating(4)
                .reviewSummary("Good food but service can improve.")
                .build()
        ),
        ReturnEditsMode.ALL
    );


responseAction.getActionEdits().get().accept(new ActionEditsVisitor<Void>() {
        @Override
        public Void objectEdits(ObjectEdits response) {
            System.out.println("Edited Objects " + response);
            return null;
        }

        @Override
        public Void largeScaleObjectEdits(ObjectTypeEdits response) {
            System.out.println("Edited ObjectTypes: " + response);
            return null;
        }
    });

レスポンスの例：

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
    "edits": {
        "type": "edits",
        "edits": [
            {
                "type": "modifyObject",
                "primaryKey": "restaurantId1",
                "objectType": "Restaurant"
            },
            {
                "type": "modifyObject",
                "primaryKey": "restaurantId2",
                "objectType": "Restaurant"
            }
        ],
        "addedObjectCount": 0,
        "modifiedObjectsCount": 2,
        "deletedObjectsCount": 0,
        "addedLinksCount": 0,
        "deletedLinksCount": 0
    }
}

関数

Palantir プラットフォームの関数（「オブジェクトに対する関数」または FoO と呼ばれることもあります）は、データモデリングとデータ操作を強化するために設計された強力な機能です。関数は、オントロジーに保存されたデータに対してカスタムロジックを定義し、実行する方法を提供します。これにより、ユーザーはより高度なデータ変換、検証、分析を作成できます。

Java SDK 内では、生成されたクエリを通じて Foundry 関数を実行できます。

アプリケーションに関数を追加すると、FoO を呼び出してロジックを実行し、結果を取得するクエリを生成できます。

この例では、ID を受け取り、類似するすべての Restaurants を含む ObjectSet を返す関数 findSimilarRestaurants を使用します。

類似する `Restaurants` を検索する関数を実行するためのパラメーター（`findSimilarRestaurants`）

プロパティ	API名	データ型
レストランID	`restaurantId`	文字列

戻り値：RestaurantObjectSet

関数を適用する

関数を適用するには、クエリにアクセスして実行する必要があります。.queries() にアクセスし、.execute(...).getReturnValue() を通じてロジック関数を実行します。

クエリの例：

Copied!1
2
3
4
5
6
RestaurantObjectSet response = client
    .ontology()
    .queries()
    .findSimilarRestaurants()
    .execute("restaurantId")
    .getReturnValue();

Media Reference プロパティ

Palantir プラットフォームの Media Reference は、MediaSet 内のメディアへの参照です。

Java SDK では、元メディアセットに対してメディアを upload および download できる Media Reference プロパティを追加できます。

次の例では、特定の Restaurant オブジェクトに関連付けられたメニューを表す restaurantMenu プロパティがあります。

`Restaurants` のメディアにアクセスするためのプロパティ（`restaurantMenu`）

プロパティ	API名	データ型
レストランメニュー	`restaurantMenu`	メディア

また、Restaurant に関連付けられた restaurantMenu を変更できる、ChangeMenu というアクションも定義されています。

`Restaurant` のメニューを変更するためのパラメーター（`ChangeMenu`）

プロパティ	API名	データ型
レストランID	`restaurantId`	文字列
レストランメニュー	`restaurantMenu`	メディア

Media Reference プロパティを持つオブジェクト/インターフェース

Copied!1
2
Restaurant restaurant = client.ontology().objects().Restaurant().fetch(primaryKey).orElseThrow();
Media restaurantMenu = restaurant.restaurantMenu().get();

Media Reference プロパティの定義

Media Reference プロパティは、インターフェースとしてユーザーに公開されます。このプロパティにはデータを取得する関数があり、それらは内部で実装されていて、ユーザーには公開されません。getId() にアクセスすると、基になる MediaReferenceId を取得できます。

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public interface Media {

    /**
     * Media Reference の識別子を取得します。
     */
    MediaReferenceId getId();

    /**
     * オブジェクトの Media Reference プロパティのメタデータを取得します。
     */
    MediaMetadata fetchMetadata();

    /**
     * オブジェクトの Media Reference プロパティに関連付けられたメディア
     * ファイルを読み込むための新しいストリームを開きます。
     */
    @MustBeClosed
    InputStream openStream();
}

メタデータを取得する

MediaMetadata を取得するには、restaurantMenu.fetchMetadata() を呼び出します。

Copied!1
2
Media restaurantMenu = restaurant.restaurantMenu().get();
MediaMetadata restaurantMenuMetadata = restaurantMenu.fetchMetadata();

メディアをダウンロードする

メディアをダウンロードするには、restaurantMenu.openStream() を呼び出して、内容を取得するためのストリームを受け取ります。

Copied!1
2
3
4
5
try (InputStream inputStream = restaurant.restaurantMenu().get().openStream()) {
        byte[] fileBytes = inputStream.readAllBytes();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }

メディアをアップロードする

メディアファイルをアップロードするには、まず元メディアセット自体にアップロードします。次に、アップロードした MediaItem を特定のオブジェクトにリンクします。

各 ObjectSet には、特定のプロパティの元 MediaSet にメディアをアップロードするメソッドがあります。このメソッドは、アップロードしたメディアの Media Reference を表す Media インスタンスを返します。この例では、オブジェクトに生成された uploadRestaurantMenu() メソッドがあり、元 MediaSet にメディアをアップロードできます。

Copied!1
2
3
4
5
6
7
8
9
Media media =
        client.ontology()
                .objects()
                .Restaurant()
                .uploadRestaurantMenu(UploadMediaRequest.builder()
                        .mediaItemPath(...)
                        .mediaType(...)
                        .inputStream(...)
                        .build());

アップロードに成功すると、返された Media オブジェクトを使用し、適切なアクションを実行して、アップロードしたメディアアイテムを対応するオブジェクトにリンクできます。

アクション内のメディア

アップロードして結果の Media オブジェクトを取得した後、アクションで Media Reference を使用して、その Media Reference を特定のオブジェクトのメディアプロパティに関連付けることができます。

Copied!1
2
3
4
5
6
client.ontology()
        .actions()
        .changeMenuAction()
        .apply(ChangeMenuActionRequest.builder()
                .restaurant_menu(media)
                .build());

アクションで別のオブジェクトの Media Reference を使用することもできます。

Copied!1
2
3
4
5
6
client.ontology()
        .actions()
        .changeMenuAction()
        .apply(ChangeMenuActionRequest.builder()
                .restaurant_menu(restaurant.restaurantMenu().get())
                .build());

Media Reference は、どこで使用される場合でも、同じ MediaSet を参照する必要があります。つまり、たとえば MediaItem を MediaSet A にアップロードした後、その MediaItem を MediaSet B にリンクすることはできません。

Java オントロジー SDK

単一の Restaurant を読み込む

Restaurants のストリームを読み込む

すべての Restaurants を読み込む

取得オプション

並べ替えた結果を読み込む

フィルタリング

検索フィルターの種類（RestaurantFilter）

指定した値で始まる

いずれかの語句を含む

すべての語句を含む

すべての語句を順序どおりに含む

範囲比較

等しい

null チェック

Not フィルター

And フィルター

Or フィルター

集計

集計の種類（Aggregation）

近似ユニーク値数

件数

数値集計

グループ化の種類（GroupBy）

完全一致によるグループ化

数値バケット化

範囲によるグループ化

日時によるグループ化

オントロジーに対するアクション

Restaurant にレビューを追加するためのパラメーター（AddRestaurantReview）

アクションを適用する

バッチアクションを適用する

関数

類似する Restaurants を検索する関数を実行するためのパラメーター（findSimilarRestaurants）

関数を適用する

Media Reference プロパティ

Restaurants のメディアにアクセスするためのプロパティ（restaurantMenu）

Restaurant のメニューを変更するためのパラメーター（ChangeMenu）

Media Reference プロパティを持つオブジェクト/インターフェース

Media Reference プロパティの定義

メタデータを取得する

メディアをダウンロードする

メディアをアップロードする

アクション内のメディア

単一の `Restaurant` を読み込む

`Restaurants` のストリームを読み込む

すべての `Restaurants` を読み込む

検索フィルターの種類（`RestaurantFilter`）

`Not` フィルター

`And` フィルター

`Or` フィルター

集計の種類（`Aggregation`）

グループ化の種類（`GroupBy`）

`Restaurant` にレビューを追加するためのパラメーター（`AddRestaurantReview`）

類似する `Restaurants` を検索する関数を実行するためのパラメーター（`findSimilarRestaurants`）

`Restaurants` のメディアにアクセスするためのプロパティ（`restaurantMenu`）

`Restaurant` のメニューを変更するためのパラメーター（`ChangeMenu`）