Developer toolchainオントロジー SDKJava オントロジー SDK (OSDK)

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

Java オントロジー SDK (OSDK)

このページでは、レストランオブジェクトとそれに関連するアクションとクエリを例にして、Java OSDK の一般的なドキュメントを提供します。プラットフォームの Developer Console を使用して、ユーザーの特定のオントロジーに基づいてドキュメントを生成できます。

プロパティ	API 名	タイプ
`Restaurant Id` (主キー)	`restaurantId`	String
`Restaurant Name` (タイトル)	`restaurantName`	String
`Address`	`address`	String
`E Mail`	`eMail`	String
`Number Of Reviews`	`numberOfReviews`	Integer
`Phone Number`	`phoneNumber`	String
`Review Summary`	`reviewSummary`	String
`Date Of Opening`	`dateOfOpening`	LocalDate

単一の `Restaurant` をロードする

パラメーター:

primaryKey string: 取得したい Restaurant の主キークエリの例:

Copied!1
2
3
Restaurant result = client.ontology().objects().Restaurant().fetch("primaryKey").orElseThrow();
// クライアントのオンテロジーからRestaurantオブジェクトを取得し、プライマリキーで検索
// 見つからなかった場合は例外をスロー

Copied!1
2
3
4
5
6
7
8
9
10
11
{
    "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000", // レコードID
    "__primaryKey": "Restaurant Id", // 主キー
    "eMail": "E Mail", // メールアドレス
    "restaurantId": "Restaurant Id", // レストラン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
2
Stream<Restaurant> result = client.ontology().objects().Restaurant().fetchStream()
// クライアントのオントロジーからRestaurantオブジェクトのストリームを取得

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", // リソースID
            "__primaryKey": "Restaurant Id", // 主キー
            "eMail": "E Mail", // メールアドレス
            "restaurantId": "Restaurant Id", // レストランID
            "address": "Address", // 住所
            "reviewSummary": "Review Summary", // レビューの概要
            "phoneNumber": "Phone Number", // 電話番号
            "numberOfReviews": 123, // レビュー数
            "restaurantName": "Restaurant Name", // レストラン名
        },
        // ... 残りのページ
    ]
}

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

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

このエンドポイントは、オブジェクトタイプに使用される基礎的なオブジェクト同期技術を活用しています。Restaurant が Object Storage V2 を利用したものである場合、リクエストの制限はありません。Restaurant が Object Storage V1 (Phonograph) を利用したものである場合、結果の上限は 10,000 件です。10,000 件以上の Restaurants がリクエストされた場合、ObjectsExceededLimit エラーが発生します。

クエリの例:

Copied!1
2
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", // レストランID
            "address": "Address", // 住所
            "reviewSummary": "Review Summary", // レビューの概要
            "phoneNumber": "Phone Number", // 電話番号
            "numberOfReviews": 123, // レビューの数
            "restaurantName": "Restaurant Name", // レストランの名前
        },
        // ... 残りのデータ
    ]
}

並べ替えられた結果をロードする

特定のプロパティに対する並べ替え方向を指定して、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<Aircraft> result = client.ontology()
    .objects()
    .Restaurant()
    .orderBy(RestaurantOrdering.RESTAURANT_NAME_ASC) // レストラン名を昇順で並べ替える
    .fetchStream();

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))  // レストラン名がnullでないレストランをフィルタリング
    .fetchStream()  // ストリームとしてデータを取得
    .toList();  // ストリームをリストに変換

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", // 主キーとして使われるレストランのID
            "restaurantName": null, // レストランの名前
            // ... Rest of properties
        },
        // ... Rest of page
    ]
}

検索フィルターの種類 (`RestaurantFilter`)

Starts with

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

パラメーター:

フィールド method: 使用するプロパティの名前（例: restaurantName）。
値 string: Restaurant Name に対してプレフィックス一致を行うために使用する値。たとえば、"foo" は "foobar" に一致しますが、"barfoo" には一致しません。

クエリの例:

Copied!1
2
3
4
5
RestaurantObjectSet result = client.ontology()
    .objects()
    .Restaurant()
    .where(RestaurantFilter.restaurantName().startsWith("foo"));
// "foo"で始まるレストラン名を持つレストランオブジェクトを取得するクエリ

Copied!1
2
3
4
5
6
7
8
9
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id",  // レストランID
        "restaurantName": "foobar",  // レストランの名前
        // ... Rest of properties
    }]
}

任意の用語を含む

String プロパティにのみ適用されます。提供された値内の空白で区切られた単語のいずれかを含む (大文字小文字を区別しない) 任意の順序で restaurantName を含む Restaurants を返します。

パラメーター:

field method: 使用するプロパティの名前 (たとえば、restaurantName)。
value string: 一致させる空白区切りの単語セット。たとえば、"foo bar" は "bar baz" に一致しますが、"baz qux" には一致しません。

例: クエリ:

Copied!1
2
3
4
5
6
7
8
9
10
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    .where(RestaurantFilter.restaurantName().containsAnyTerm("foo bar"));

// client.ontology() でオントロジークライアントを取得
// .objects() でオブジェクトを取得
// .Aircraft() で特定のオブジェクトタイプ（ここではAircraft）を指定
// .where() でフィルタ条件を設定
// RestaurantFilter.restaurantName().containsAnyTerm("foo bar") でレストラン名が "foo bar" を含む場合をフィルタリング

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", // 主キー（レストランID）
            "restaurantName": "foo bar baz",
            // ... 残りのプロパティ
        },
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000001",
            "restaurantName": "bar baz",
            // ... 残りのプロパティ
        },
    ]
}

Contains all terms

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

パラメーター:

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

クエリの例:

Copied!1
2
3
4
5
6
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    .where(RestaurantFilter.restaurantName().containsAllTerms("foo bar"));
    // クライアントのオンテロジーからオブジェクトを取得し、"foo bar" という全ての単語を含むレストラン名でフィルタリングする
    // 結果は RestaurantObjectSet に格納される

Copied!1
2
3
4
5
6
7
8
9
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id", // 主キーとして使われるレストラン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
5
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    // "foo bar"という文字列が含まれているレストラン名をフィルター
    .where(RestaurantFilter.restaurantName().containsAllTermsInOrder("foo bar"));

Copied!1
2
3
4
5
6
7
8
9
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id", // プライマリキーとしてレストランIDを指定
        "restaurantName": "foo bar baz", // レストラン名
        // ... 他のプロパティ
    }]
}

範囲比較

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

パラメーター:

field method: 使用するプロパティの名前 (たとえば、restaurantName)
value string: Restaurant Name と比較する値

比較タイプ:

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

クエリの例:

Copied!1
2
3
4
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft() // オブジェクトの種類としてAircraft（航空機）を指定
    .where(RestaurantFilter.restaurantName().lt("Restaurant Name")); // "Restaurant Name"よりも小さいレストラン名を持つオブジェクトをフィルタリング

Equal to

Boolean、DateTime、Numeric、String プロパティにのみ適用されます。restaurantName が指定された値と等しい Restaurants を検索します。

パラメーター:

field method: 使用するプロパティの名前 (たとえば、restaurantName)。
value string: Restaurant Name と等しいかどうかを確認する値。

例クエリ:

Copied!1
2
3
4
5
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    // フィルタで特定のレストラン名を持つオブジェクトを検索
    .where(RestaurantFilter.restaurantName().eq("Restaurant Name"));

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    // 次のページを取得するためのトークン
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        // リソースのID
        "__primaryKey": "Restaurant Id",
        // プライマリキー（レストランID）
        "restaurantName": "Restaurant Name",
        // レストランの名前
        // ... その他のプロパティ
    }]
}

Null チェック

Array、Boolean、DateTime、Numeric、および String プロパティにのみ適用されます。restaurantName の値が存在するかどうかに基づいて Restaurants を検索します。

パラメーター:

field method: 使用するプロパティの名前 (たとえば、restaurantName)。
value boolean: Restaurant Name が存在するかどうか。TypeScript SDK では、フィールドが null でないことを確認するために not フィルター処理する必要があることに注意してください。

クエリの例:

Copied!1
2
3
4
5
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    .where(RestaurantFilter.restaurantName().isNull(true));
// レストラン名がnullであるレストランオブジェクトを取得するクエリを実行

`Not` フィルター処理する

クエリが満たされていない Restaurants を返します。これは、他のブール値のフィルター処理操作とさらに組み合わせることができます。

パラメーター:

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

クエリの例:

Copied!1
2
3
4
5
6
7
8
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft() // 飛行機オブジェクトを取得
    .where(
        RestaurantFilter.$not( // 条件に一致しないものをフィルタリング
            RestaurantFilter.restaurantName().isNull(true) // レストラン名がnullであるものを除外
        )
    );

`And` フィルター処理する

すべてのクエリが満たされるRestaurantsを返します。これを他のブールフィルター処理操作とさらに組み合わせることができます。

パラメーター:

value Filter[]: 一緒にandする検索クエリのセット。

クエリの例:

Copied!1
2
3
4
5
6
7
8
9
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft() // Restaurantオブジェクトを取得
    .where(
        RestaurantFilter.$and( // 複数の条件をANDで結合
            RestaurantFilter.restaurantName().isNull(false), // restaurantNameがnullでないことを確認
            RestaurantFilter.restaurantName().eq("<primarykey>") // restaurantNameが指定したprimary keyと一致することを確認
        )
    );

`Or` フィルター

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

パラメーター:

value Filter[]: 一緒に or する検索クエリのセット。

クエリ例:

Copied!1
2
3
4
5
6
7
8
9
RestaurantObjectSet result = client.ontology()
    .objects()
    .Aircraft()
    .where(
        RestaurantFilter.$or(
            RestaurantFilter.restaurantName().isNull(false), // restaurantNameがnullでない場合
            RestaurantFilter.restaurantName().eq("<primarykey>") // restaurantNameが<primarykey>と等しい場合
        )
    );

集計

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

このエンドポイントは、オブジェクトタイプに使用される基礎となるオブジェクト同期技術を活用しています。Restaurant が Object Storage V2 を利用している場合、リクエストの制限はありません。Restaurant が Object Storage V1 (Phonograph) を利用している場合、結果の上限は 10,000 件です。10,000 件以上の Restaurant が要求された場合、ObjectsExceededLimit エラーが発生します。

Restaurant で集計を実行します。

パラメーター:

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)) // レストラン名がnullでないレストランをフィルタリング
        .groupBy(GroupBy.exact(Restaurant.Property.restaurantName())) // レストラン名でグループ化
        .count() // 各グループの件数をカウント
        .compute(); // 集計を実行

{
    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();

{
    excludedItems: 0,  // 除外された項目の数
    data: [{
        group: {},  // グループ情報（ここでは空のオブジェクト）
        metrics: [
            {
                name: "distinctCount",  // メトリクスの名前（ここではユニークなカウント）
                value: 100  // メトリクスの値
            }
        ]
    }]
}

カウント

Restaurants の合計数を計算します。

パラメーター:

name string (オプション): 計算されたカウントのエイリアス。デフォルトでは、これは count です。

クエリ例:

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

// clientオブジェクトを使用して、ontologyメソッドでオントロジーにアクセス
// objectsメソッドでオブジェクトを取得し、Restaurantメソッドでレストランのオブジェクトを選択
// countメソッドでレストランの数をカウントし、computeメソッドで計算を実行して結果を取得

{
    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();

{
    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(); // 集計を実行

数値バケッティング

指定された幅で 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)) // レビュー数でレストランを10件ごとにグループ化
       .count() // 各グループ内のレストラン数をカウント
       .compute(); // 集計を実行

範囲グループ化

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), // レビュー数が0から3の範囲
                AggregationRange.of(3, 5)  // レビュー数が3から5の範囲
            )
        )
    )
    .count() // 各グループのカウントを取得
    .compute(); // 集計を実行

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      // メトリクスの値（ここでは件数の値）
                }
            ]
        }
    ]
}

日時グループ化

特定の日付/時間の期間のバケットを介して Restaurants を dateOfOpening でグループ化します。

パラメーター:

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)) // レストランの開店日を10日ごとにグループ化
       .count() // 各グループ内のレストラン数をカウント
       .compute(); // 集計結果を計算

{
    excludedItems: 0,  // 除外されたアイテムの数
    data: [{
        group: {
            "dateOfOpening": {
                startValue: "2024-09-25"  // 開始日
            }
        },
        metrics: [
            {
                name: "count",  // メトリクス名
                value: 100  // メトリクスの値
            }
        ]
    }]
}

オントロジーでのアクション

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

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

プロパティ	API 名	タイプ
`Restaurant Id`	`restaurantId`	String
`Review Rating`	`reviewRating`	Integer
`Review Summary`	`reviewSummary`	String

アクションを適用

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

パラメーター:

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
26
27
AddReviewActionResponse response = client.ontology()
    .actions()
    .addReview()
    .apply(
        AddReviewActionRequest.builder()
            .restaurantId(restaurantId) // レストランのIDを設定
            .reviewRating(5) // レビューの評価を設定（ここでは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;
    }
});

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",  // restaurantIdが有効であることを示します
                "evaluatedConstraints": [],  // 評価された制約はありません
                "required": true  // 必須パラメータであることを示します
            },
            "reviewRating": {
                "result": "VALID",  // reviewRatingが有効であることを示します
                "evaluatedConstraints": [],  // 評価された制約はありません
                "required": true  // 必須パラメータであることを示します
            },
            "reviewSummary": {
                "result": "VALID",  // reviewSummaryが有効であることを示します
                "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
34
35
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 // 削除されたリンクの数
    }
}

Functions

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

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

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

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

類似する `Restaurants` を見つける関数 (`findSimilarRestaurants`) を実行するためのパラメーター

プロパティ	API 名	タイプ
`Restaurant Id`	`restaurantId`	String

戻り値: RestaurantObjectSet

関数の適用

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

クエリの例:

Copied!1
2
3
4
5
6
RestaurantObjectSet response = client
    .ontology() // オントロジー関連の操作を行うオブジェクト
    .queries() // クエリ関連の操作を行うオブジェクト
    .findSimilarRestaurants() // 類似するレストランを検索するメソッド
    .execute("restaurantId") // 指定したレストランIDでメソッドを実行
    .getReturnValue(); // 実行結果を取得

Java オントロジー SDK (OSDK)

単一の Restaurant をロードする

Restaurantsのストリームをロードする

すべての Restaurants を読み込む

並べ替えられた結果をロードする

フィルター処理

検索フィルターの種類 (RestaurantFilter)

Starts with

任意の用語を含む

Contains all terms

すべての用語を順序通りに含む

範囲比較

Equal to

Null チェック

Not フィルター処理する

And フィルター処理する

Or フィルター

集計

集計の種類 (Aggregation)

おおよその重複排除

カウント

数値集計

グループ化の種類 (GroupBy)

正確なグループ化

数値バケッティング

範囲グループ化

日時グループ化

オントロジーでのアクション

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

アクションを適用

バッチアクションの適用

Functions

類似する Restaurants を見つける関数 (findSimilarRestaurants) を実行するためのパラメーター

関数の適用

単一の `Restaurant` をロードする

`Restaurants`のストリームをロードする

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

検索フィルターの種類 (`RestaurantFilter`)

`Not` フィルター処理する

`And` フィルター処理する

`Or` フィルター

集計の種類 (`Aggregation`)

グループ化の種類 (`GroupBy`)

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

類似する `Restaurants` を見つける関数 (`findSimilarRestaurants`) を実行するためのパラメーター