Java Ontology SDK (OSDK)

This page provides generic documentation for the Java OSDK based on an example Restaurant object and its associated Actions and Queries. You can use Developer Console in the platform to generate documentation based on your specific Ontology.

Load single Restaurant

Parameters:

• primaryKey string: The primary key of the Restaurant you want to fetch Example query:

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

Example API response:

{
    "__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",
}

Load a stream of Restaurants

Load a stream of objects that can be collected. This automatically loads pages of objects depending on how many objects are streamed by the user.

Note that this endpoint leverages the underlying object syncing technology used for the object type. If Restaurant is backed by Object Storage V2, there is no request limit. If Restaurant is backed by Object Storage V1 (Phonograph), there is a limit of 10,000 results; if more than 10,000 Restaurants have been requested, an ObjectsExceededLimit error will be thrown.

Example query:

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

Example API response:

{
    "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",
        },
        // ... Rest of page
    ]
}

Load all Restaurants

Loads all Restaurant Objects into a list.

Note that this endpoint leverages the underlying object syncing technology used for the object type. If Restaurant is backed by Object Storage V2, there is no request limit. If Restaurant is backed by Object Storage V1 (Phonograph), there is a limit of 10,000 results; if more than 10,000 Restaurants have been requested, an ObjectsExceededLimit error will be thrown.

Example query:

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

Example API response:

{
    "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",
        },
        // ... Rest of data
    ]
}

Load ordered results

Load an ordered list of Restaurants by specifying a sort direction for specific properties. When calling via APIs, sorting criteria are specified via the fields array. When calling via SDKs, you can chain multiple orderBy calls together. The sort order for strings is case-sensitive, meaning numbers will come before uppercase letters, which will come before lowercase letters. For example, Cat will come before bat.

Parameters:

• ordering {ObjectType}Ordering: The property you want to order by. With the Java SDK, this is provided for you via a {ObjectType}Ordering interface.
• property name and direction ASC| DESC : The direction you want to sort in, either ascending or descending. With the Java SDK, this is provided via the {PROPERTY_NAME}_ASC and {PROPERTY_NAME}_DESC qualifiers on the {ObjectType}Ordering interface.

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Object A",
            "restaurantName": "A",
            // ...Rest of properties
        },
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Object B",
            "restaurantName": "B",
            // ...Rest of properties
        },
        // ...Rest of page
    ]
}

Filtering

The types of filtering you can perform depend on the types of the properties on a given object type. These filters can also be combined together via Boolean expressions to construct more complex filters.

Note that this endpoint leverages the underlying object syncing technology used for the object type. If Restaurant is backed by Object Storage V2, there is no request limit. If Restaurant is backed by Object Storage V1 (Phonograph), there is a limit of 10,000 results; if more than 10,000 Restaurants have been requested, an ObjectsExceededLimit error will be thrown.

Parameters:

• where Filter (optional): Filter on a particular property. The possible operations depend on the type of the property. This is represented through {ObjectType}Filter with methods to call for each property.
• orderBy OrderBy (optional): Order the results based on a particular property. If using the SDK, you can chain the .where call with an orderBy call to achieve the same result. This is represented through {ObjectType}OrderBy with methods to call for each property.

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": null,
            // ... Rest of properties
        },
        // ... Rest of page
    ]
}

Types of search filters (RestaurantFilter)

Starts with

Only applies to String properties. Searches for Restaurants where restaurantName starts with the given string (case insensitive).

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: Value to use for prefix matching against Restaurant Name. For example, "foo" will match "foobar" but not "barfoo".

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id",
        "restaurantName": "foobar",
        // ... Rest of properties
    }]
}

Contains any terms

Only applies to String properties. Returns Restaurants where restaurantName contains any of the whitespace separated words (case insensitive) in any order in the provided value.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: White-space separated set of words to match on. For example, "foo bar" will match "bar baz" but not "baz qux".

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
            "__primaryKey": "Restaurant Id",
            "restaurantName": "foo bar baz",
            // ... Rest of properties
        },
        {
            "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000001",
            "restaurantName": "bar baz",
            // ... Rest of properties
        },
    ]
}

Contains all terms

Only applies to String properties. Returns Restaurants where restaurantName contains all of the whitespace separated words (case insensitive) in any order in the provided value.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: White-space separated set of words to match on. For example, "foo bar" will match "hello foo baz bar" but not "foo qux".

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id",
        "restaurantName": "hello foo baz bar",
        // ... Rest of properties
    }]
}

Contains all terms in order

Only applies to String properties. Returns Restaurants where restaurantName contains all of the terms in the order provided (case insensitive), but they do have to be adjacent to each other.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: White-space separated set of words to match on. For example, "foo bar" will match "hello foo bar baz" but not "bar foo qux".

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id",
        "restaurantName": "foo bar baz",
        // ... Rest of properties
    }]
}

Range comparison

Only applies to Numeric, String and DateTime properties. Returns Restaurants where Restaurant.restaurantName is less than a value.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: Value to compare Restaurant Name to

Comparison types:

• Less than lt
• Greater than gt
• Less than or equal to lte
• Greater than or equal to gte

Example query:

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

Equal to

Only applies to Boolean, DateTime, Numeric, and String properties. Searches for Restaurants where restaurantName equals the given value.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value string: Value to do an equality check with Restaurant Name.

Example query:

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

Example API response:

{
    "nextPageToken": "v1.000000000000000000000000000000000000000000000000000000000000000000000000",
    "data": [{
        "__rid": "ri.phonograph2-objects.main.object.00000000-0000-0000-0000-000000000000",
        "__primaryKey": "Restaurant Id",
        "restaurantName": "Restaurant Name",
        // ... Rest of properties
    }]
}

Null check

Only applies to Array, Boolean, DateTime, Numeric, and String properties. Searches for Restaurants based on whether a value for restaurantName exists or not.

Parameters:

• field method: Name of the property to use (e.g. restaurantName).
• value boolean: Whether or not Restaurant Name exists. Note for the TypeScript SDK, you will need to use a not filter for checking that fields are non-null.

Example query:

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

Not filter

Returns Restaurants where the query is not satisfied. This can be further combined with other boolean filter operations.

Parameters:

• value Filter: The search query to invert.

Example query:

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

And filter

Returns Restaurants where all queries are satisfied. This can be further combined with other boolean filter operations.

Parameters:

• value Filter[]: The set of search queries to and together.

Example query:

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

Or filter

Returns Restaurants where any of the specified queries are satisfied. This can be further combined with other Boolean filter operations.

Parameters:

• value Filter[]: The set of search queries to or together.

Example query:

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

Aggregations

Aggregations allow you to compute summary statistics over a set of data. They are useful for understanding patterns and insights from large datasets without having to manually analyze each individual data point. You can combine multiple aggregation operations to create more complex queries that provide deeper insights into the data.

Note that this endpoint leverages the underlying object syncing technology used for the object type. If Restaurant is backed by Object Storage V2, there is no request limit. If Restaurant is backed by Object Storage V1 (Phonograph), there is a limit of 10,000 results; if more than 10,000 Restaurants have been requested, an ObjectsExceededLimit error will be thrown.

Perform aggregations on Restaurants.

Parameters:

• aggregation Aggregation[] (optional): Set of aggregation functions to perform. With the SDK, aggregation computations can be chained together with further searches using .where.
• groupBy GroupBy[] (optional): A set of groupings to create for aggregation results
• where Filter (optional): Filter on a particular property. The possible operations depend on the type of the property.

Example query:

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

Example API response:

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

Types of Aggregations (Aggregation)

Approximate distinct

Computes an approximate number of distinct values for restaurantName.

Parameters:

• field Property: Name of the property to use (e.g. restaurantName).
• name string (optional): Alias for the computed count. By default, this is distinctCount.

Example query:

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

// This is equivalent to the above, but uses metricName as the metric name instead of the default "distinctCount"

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

Example API response:

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

Count

Computes the total count of Restaurants.

Parameters:

• name string (optional): Alias for the computed count. By default, this is count.

Example query:

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

Example API response:

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

Numeric aggregations

Only applies to numeric properties. Calculate the maximum, minimum, sum, or average of a numeric property for Restaurants.

Parameters:

• field NumericProperty: Name of the property to use (e.g. numberOfReviews).
• name string (optional): An alias for the computed value.

Aggregation types:

• Average: avg()
• Maximum: max()
• Minimum: min()
• Sum: sum()

Example query:

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

// This is equivalent to the above, but uses avgReview as the metric name instead of the default "avg"

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

Example API response:

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

Types of group bys (GroupBy)

Exact grouping

Groups Restaurants by exact values of restaurantName.

Parameters:

• field Property: Name of the property to use (e.g. restaurantName).
• maxGroupCount integer (optional): Maximum number of groupings of restaurantName to create.

Example query:

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

Example API response:

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

Numeric bucketing

Groups Restaurants by dividing numberOfReviews into buckets with the specified width.

Parameters:

• field NumericProperty: Name of the property to use (e.g. numberOfReviews).
• fixedWidth integer (optional): Width of each bucket to divide the selected property into.

Example query:

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

Example API response:

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

Range grouping

Groups Restaurants by specified ranges of numberOfReviews.

Parameters:

• field NumericProperty | DateProperty | TimestampProperty: Name of the property to use (e.g. numberOfReviews).
• ranges AggregationRange[] (optional): Set of ranges which have an inclusive start value and exclusive end value.

Example query:

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

Example API response:

{
    "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
                }
            ]
        }
    ]
}

Datetime grouping

Groups Restaurants by dateOfOpening via buckets of a specific date/time duration.

Parameters:

• field DateProperty | TimestampProperty: Name of the property to use (e.g. dateOfOpening).
• value integer (optional): The number of duration units to group by.

Duration types:

• Seconds bySeconds()
• Minutes byMinutes()
• Hours byHours()
• Days byDays()
• Weeks byWeeks()
• Months byMonths()
• Quarters byQuarters()
• Years byYears()

Example query:

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

Example API response:

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

Actions on the Ontology

Action types in the ontology refer to predefined operations that you can perform on objects within your data model. These actions can create, modify, and delete objects in the ontology. Action types are generated based on the ontology and can be used within the Java OSDK to perform specific tasks on objects in the code.

Parameters for adding a review to a Restaurant (AddRestaurantReview)

Apply action

To apply an action, fill in the input parameter values. This will execute an action and return if the response was valid or invalid.

Parameters:

• parameters Object: Map of parameter ID to values to use for those input parameters.
  • restaurantId string
  • reviewRating integer
  • reviewSummary string
• options integer (optional): The number of duration units to group by.

Example Query:

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;
    }
});

Example API response:

{
    "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
    }
}

Apply batch action

To apply a batch of actions, fill in the input parameter values. This will execute a series of action and return if the response was valid or invalid. Note that this does not return validations, only edits.

Parameters:

• parameters Object: Map of parameter ID to values to use for those input parameters.
  • restaurantId string
  • reviewRating integer
  • reviewSummary string
• value ReturnEditsMode.(ALL|NONE) (optional): Whether the edits are returned in the response after the action is applied.

Example Query:

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;
        }
    });

Example Response:

{
    "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 (sometimes referred to as "functions on objects" or FoO) in the Palantir platform are a powerful feature designed to enhance data modeling and manipulation. Functions provide a way to define and execute custom logic on the data stored in the Ontology, allowing users to create more sophisticated data transformations, validations, and analytics.

Within the Java SDK, a user can execute Foundry Functions through generated queries.

By adding your functions to your application, you can generate Queries that call FoO to execute logic and get the result.

In this example, we have a function findSimilarRestaurants that takes in an ID and returns an ObjectSet containing all the similar Restaurants.

Parameters for executing a function to find similar Restaurants(findSimilarRestaurants)

Returns: RestaurantObjectSet

Apply function

To apply a function, you must access and execute a query. This is done by accessing .queries() and executing the logic function through .execute(...).getReturnValue()

Example Query:

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