ESM: import * as knowledgeGraphService from "@arcgis/core/rest/knowledgeGraphService.js";
CDN: const knowledgeGraphService = await $arcgis.import("@arcgis/core/rest/knowledgeGraphService.js");
Object: @arcgis/core/rest/knowledgeGraphService
Since: ArcGIS Maps SDK for JavaScript 4.25
A knowledge graph service is associated with several resources. One resource is a knowledge graph, which contains entities and relationships. Another resource is the data model that defines the entity types and relationship types in the graph. A third resource is the service definition which outlines the capabilities of the service. A knowledge graph service allows users to query both the knowledge graph and the data model. Entities and relationships can be added, updated or deleted from the knowledge graph using executeApplyEdits(). To visualize knowledge graph data on map, see knowledge graph layer.
Known Limitations
KnowledgeGraphService capabilities in version 4.26 of the SDK for Javascript are only supported against ArcGIS Enterprise version 11.1 and later. KnowledgeGraphService capabilities in version 4.25 of the SDK for Javascript are supported on ArcGIS Enterprise version 11.0 and earlier.
Method Overview Method Details executeAddGraphFieldIndex(graph, namedType, fieldIndexes, options){Promise<GraphAddFieldIndexResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeAddGraphFieldIndex added at 4.33.
Adds a field index for a particular property on an entity type or relationship type in a graph.
Note
Returns
executeAddGraphProperties(graph, namedType, namedTypeProperties, options){Promise<GraphAddPropertyResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeAddGraphProperties added at 4.33.
Add a GraphProperty for a particular entity type or relationship type.
Note
Returns
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeAddNamedTypes added at 4.33.
Returns
Example
const knowledgeGraphModule = await $arcgis.import("@arcgis/core/rest/knowledgeGraphService.js");
// use fetchKnowledgeGraph() to retrieve the knowledge graph
// define the new entity type
const newEntityType = {
type: "entity",
name: "Person",
properties: [
{
name: "nameProp",
alias: "Name",
fieldType: "esriFieldTypeString",
role: "esriGraphPropertyRegular",
},
],
};
// define a new relationship type
const newRelationshipType = {
type: "relationship",
name: "knows",
properties: [
{
name: "dateMet",
fieldType: "esriFieldTypeTimestampOffset",
role: "esriGraphPropertyRegular",
},
],
endPoints: [
{
originEntityType: "Person",
destinationEntityType: "Person",
},
],
};
// add the new types, update the data model and get the updated graph.
knowledgeGraphModule.executeAddNamedTypes(graph,
{
newEntityTypes: [newEntityType],
newRelationshipTypes: [newRelationshipType]
}).then((response) => {
graph = response.updatedKnowledgeGraph;
})Add, delete, or update entities and relationships in a knowledge graph service's graph resource. This operation does not allow adding or deleting properties for entity types or relationship types. However, users can update an entity or relationship to change its property values.
Note
Returns
Examples
// sample executeApplyEdits() to add a new entity to the `Supplier` entity type
const newEntity = new Entity({
typeName: "Supplier",
properties: {
Name: "Supplier 5",
EmployeeCount: 681
}
});
KnowledgeGraphModule.executeApplyEdits(
graph, {
entityAdds: [newEntity]
})
.then((editResult) => {
console.log("Graph Add Result", editResult);
});
});// Basic example results of adding one entity to the `Supplier` entity type
{
editResults:[{
adds:[
{
id: "{A1W5F4A8S-41F1-49A4-8412-ANIWN9906E88}",
error: false
}],
deletes:[],
typeName: "Supplier",
updates:[]
}],
hasError: false,
error: undefined
}//update existing records
const updateEntity = new Entity({
typeName: "Supplier",
// update the EmployeeCount from 681 to 685
properties: {
Name: "Supplier 5",
EmployeeCount: 685
},
id:"{A1W5F4A8S-41F1-49A4-8412-ANIWN9906E88}" //id of entity already in knowledge graph
});
const updateRelationship = new Relationship({
typeName: "buys_part",
properties: {
quantity: 5000
},
// origin and destination entities must already exist in the graph
originId: "{AN4E4G85-41F1-49A4-8412-CACCC9906E88}",
destinationId: "{9D2D6AFD-41F1-49A4-8412-1DGR8E5D6S1G4}"
});
KnowledgeGraphModule.executeApplyEdits(
graph, {
entityUpdates: [updateEntity],
relationshipUpdates: [updateRelationship]
})
.then((editResult) => {
console.log("Graph Update Result", editResult);
});
});//delete existing records
KnowledgeGraphModule.executeApplyEdits(
graph, {
entityDeletes: [{
typeName: "Supplier",
ids: ["{AMGIE541G-41F1-49A4-8412-CACCC9906E88}", "{HNWIGHE15-WH52-2GE6-1A5W-A1F8W4FS3A1S5}"]
},{
typeName: "Part",
ids: ["{FNIW4GF1-ANFW-49A4-ANW7-GNWIGHAF4S51FS}"]
}],
relationshipDeletes: [{
typeName: "Buys_part",
ids: ["{MH4E54G8E-MF4W-1842-2S44-15AF5W8F4S2W8}"]
}],
//delete all relationships connected to the deleted entities.
options:{
cascadeDelete: true
}
})
.then((editResult) => {
console.log("Graph Delete Result", editResult);
});
}); executeDeleteGraphFieldIndex(graph, namedType, fieldIndexNames, options){Promise<GraphDeleteFieldIndexResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeDeleteGraphFieldIndex added at 4.33.
Deletes the field index for a particular property on an entity type or relationship type in a graph.
Note
Returns
executeDeleteGraphProperty(graph, namedType, propertyName, options){Promise<GraphDeletePropertyResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeDeleteGraphProperty added at 4.33.
Delete a GraphProperty for a particular entity type or relationship type. A GraphProperty can only be deleted if the entity type or relationship type has no entity or relationship records in it.
Note
Parameters
The knowledge graph to update.
The name of the entity type or relationship type to update with the property to be updated.
The name of the GraphProperty to delete.
optionalAdditional options to be used for the data request.
Returns
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeDeleteNamedType added at 4.33.
Returns
Example
const knowledgeGraphModule = await $arcgis.import("@arcgis/core/rest/knowledgeGraphService.js");
// use fetchKnowledgeGraph() to retrieve the knowledge graph
// Delete the type, update the data model and get the updated graph.
knowledgeGraphModule
.executeDeleteNamedTypes(graph,"knows")
.then((response) => {
graph = response.updatedKnowledgeGraph;
})Executes a request to the ServerFilteredFindPaths GP tool. Allows you to identify paths that connect the specified entities or entity types and satisfy all specified conditions. A path is made of a sequence of relationships and the corresponding entities.
Returns
Example
knowledgeGraphService.executeFindPaths({
inKnowledgeGraphUrl: "https://sampleserver7.arcgisonline.com/server/rest/services/Hosted/BumbleBees/KnowledgeGraphServer",
config: {
type: "CIMFilteredFindPathsConfiguration",
name: "exampleFFPconfiguration",
originEntities: [
{
type: "CIMFilteredFindPathsEntity",
iD: devPathStart,
entityTypeName: "User"
}
],
destinationEntities: [
{
type: "CIMFilteredFindPathsEntity",
iD: devPathEnd,
entityTypeName: "Species"
}
],
pathFilters: [
{
type: "CIMFilteredFindPathsPathFilter",
iD: null,
itemTypeName: "Observation",
itemType: "Entity",
filterType: "Include"
}
],
defaultTraversalDirectionType: "Any",
entityUsage: "EachPair",
pathMode: "All",
minPathLength: 1,
maxPathLength: 8,
maxCountPaths: 100000
}
}); executeFindPathsAsynchronous(toolSettings, requestOptions){Promise<JobInfo>}
Executes an asynchronous request to the ServerFilteredFindPaths GP tool. Allows you to identify paths that connect the specified entities or entity types and satisfy all specified conditions. A path is made of a sequence of relationships and the corresponding entities.
Returns
executeQuery(graph, queryArguments, requestOptions){Promise<GraphQueryResult>}
Executes a query on knowledge graph service's graph resource using the Esri implementation of openCypher and returns the results.
Returns
Example
// typical use case
KnowledgeGraphModule.executeQuery(
knowledgeGraph, //graph
{ // queryArguments
openCypherQuery: "MATCH (n) RETURN n LIMIT 100", //query
}).then((queryResult) => {
// do something with the result
}); executeQueryStreaming(graph, queryArguments, requestOptions){Promise<GraphQueryStreamingResult>}
Execute a streaming query on a knowledge graph service's graph resource. Streaming query returns a readable stream that must be read to access the returned graph data. Unlike executeQuery(), executeQueryStreaming() returns results in small chunks that can be processed immediately, without waiting for all results to be returned. Streaming query is faster and more efficient than executeQuery(). Streaming query also retrieves all matching records even if the total exceeds the maxRecordCount defined in the service without additional queries or pagination. Another benefit of streaming query is that the query is encoded which means that it is far smaller than a traditional HTTP GET or JSON POST body. This is especially important when trying to do a query on a very large argument, such as a large set of Ids or intersecting a complex geometry.
The entities and relationships in the graph are queried by sending an Esri implementation of openCypher query.
Returns
Examples
// sample streaming query using bind parameters
// to search for entities with a the `name` property that matches a specific string
// or have their geometry within a bounding box.
// get all parts bought by each supplier.
// query returns both the supplier and the part it buys.
const query = `MATCH (s:Supplier)-[:buys_part]-(p:Part)
WHERE s.name=$name OR esri.graph.ST_Intersects($geom, s.geometry)
RETURN s,p`;
KnowledgeGraphModule.executeQueryStreaming(
knowledgeGraph,
{
openCypherQuery: query,
bindParameters: {
name: "Supplier 5",
//bounding box around the area of Washington DC, USA
geom: new Polygon({
rings: [
[
[38,-78],
[39, -78],
[39, -76],
[-38, -76],
[-38, -78],
],
],
}),
}
}).then((streamingQueryResult)=>{
// streaming query returns a readableStream which must be read to access the returned graph data
readStream(streamingQueryResult)
});// a function to read the readable stream returned from the above query
const readStream = async (streamingQueryResult) => {
let time = Date.now();
let reader = streamingQueryResult.resultRowsStream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done) {
console.log(`Completed database requests: ${(Date.now() - time) / 1000} seconds`);
break;
}
console.log(`Chunk returned in: ${(Date.now() - time) / 1000} seconds`);
// use the results
// list the parts bought by each supplier
let supplierParts = {};
// each element of the result array will contain one supplier and one part it buys
for (var v in value){
let supplier = value[v][0].properties.Name
let part = value [v][1].properties.Name
if(!(supplier in supplierParts)){
supplierParts[supplier] = [];
}
// collect parts by supplier that buys them
supplierParts[supplier].push(part);
console.log(supplierParts);
// result printed to the console: {Supplier 1:[Part1], Supplier 3:[Part2, Part3]}
}
} catch (err) {
if (err.name === "AbortError") {
console.log("Request aborted as expected");
} else {
throw err;
}
}
};// result stream from above query after it has been read
"Streaming chunk returned in: 0.082 seconds"
[
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Supplier 1",
"City": "Washington DC",
"EmployeeCount": 31
},
"typeName": "Supplier",
"id": "{57FDF2F3-34C8-48EF-9A3B-76ED9314C4D2}"
},{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Part_ID": 695401,
"Name": "Part1",
"Minimum_quantity": 360
},
"typeName": "Part",
"id": "{IWN51W4-1AW8-A2W6-1AW5F-1AW8F9F4W51AS}",
}],
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Supplier 2",
"City": "Baltimore",
"EmployeeCount": 53
},
"typeName": "Supplier",
"id": "{1A4W8F5W-1WA8-5W6A-A1W8-A1W5F8W3S482A}"
},{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Part_ID": 695401,
"Name": "Part2",
"Minimum_quantity": 2500
},
"typeName": "Part",
"id": "{A1W5F8W4F-A1W8-1894-16A5-A86WF4A8SFWD}",
}],
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Supplier 2",
"City": "Baltimore",
"EmployeeCount": 53
},
"typeName": "Supplier",
"id": "{1A4W8F5W-1WA8-5W6A-A1W8-L5H4G8RT1PK3}"
},{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Part_ID": 695401,
"Name": "Part3",
"Minimum_quantity": 5000
},
"typeName": "Part",
"id": "{PTJ51FT-KY4H-1GY5-G1Y8-G1Y5K49G8Y4GHJ}",
}]
]// aborting the query
// create instance of native browser abort controller
const controller = new AbortController();
// create query
KnowledgeGraphModule.executeQueryStreaming(
knowledgeGraph,
{
openCypherQuery: "MATCH (n) RETURN n LIMIT 100",
},
{
signal: controller.signal,
}
)
.then((streamingQueryResult) => {
readStream(streamingQueryResult);
})
// indicate that the stream was aborted
.catch((err) => {
if (err.name === "AbortError") {
console.log("Request aborted as expected");
}
// abort the query after half a second
setTimeout(() => {
console.log("Sending abort signal");
controller.abort();
}, 500); executeSearch(graph, searchArguments, requestOptions){Promise<GraphQueryResult>}
Search the knowledge graph using a full-text index that is automatically built on the property values in the graph and returns the result. Search accepts Lucene search syntax. Use the DataModel to see the indexed fields for each RelationshipType and EntityType.
Returns
Type Description Promise<GraphQueryResult> When resolved, the result is a GraphQueryResult that contains all records matching the search. If there are no matches the result will be empty.Examples
// typical use case
KnowledgeGraphModule.executeSearch(
knowledgeGraph, //graph
{ // searchArguments
searchQuery: "Sun", //search term
typeCategoryFilter: "both" //search entities, relationships or both.
}).then((searchResult) => {
// do something with the result
console.log(searchResult)
});// sample search result
{
"declaredClass": "esri.rest.knowledgeGraph.GraphQueryResult",
"resultRows": [
[
{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"shape": {
"declaredClass": "esri.geometry.Point",
"cache": {},
"hasM": false,
"hasZ": false,
"latitude": 53.589000000000006,
"longitude": -0.9633,
"type": "point",
"extent": null,
"spatialReference": {
"wkid": 4326
},
"x": -0.9633,
"y": 53.589000000000006
},
"Name": "Suncommon",
"Employee_Count": 400
},
"typeName": "Company",
"id": "{WIPJ483T-U8UI-LLK9-YUI8-Y5YK8YGD88E9}",
}
],
[
{
"declaredClass": "esri.rest.Relationship.Relationship",
"originID": "{44027400-4B48-4FF2-B526-E27FC17EC246}",
"destinationID": "{CB0CF580-3899-491E-8F10-0AD1DA4EE49B}",
"properties": {
"orderDay": "Sunday",
"quantity": 15000
},
"typeName": "buys_part",
"id": "{ABCDEFG-0000-1111-2222-0AD1DA4EE49B}"
}
]
} executeSearchStreaming(graph, searchArguments, requestOptions){Promise<GraphQueryStreamingResult>}
Execute a streaming search on a knowledge graph service's graph resource. Streaming search returns a readable stream that must be read to access the returned data. Unlike executeSearch(), executeSearchStreaming() returns results in small chunks that can be processed immediately, without having to wait for all results to be returned. Streaming search is faster and more efficient than executeSearch(). Streaming search also retrieves all matching records even if the total exceeds the searchMaxRecordCount defined in the service without additional queries or pagination. Another benefit of streaming search is that the request is encoded which means that it is far smaller than a traditional HTTP GET or JSON POST body. This is especially important when trying to do a search on a very large argument, such as a large set of Ids.
Streaming search accepts Lucene search syntax. Streaming search uses a full-text index that is automatically built on the property values in the graph. Use the DataModel to see the indexed fields for each RelationshipType and EntityType.
Returns
Examples
// example search for "solar"with additional parameters
KnowledgeGraphModule.executeSearchStreaming(
knowledgeGraph,
{
searchQuery: "solar",
typeCategoryFilter: "both",
returnSearchContext: false,
start: 1,
num: 200, //return 200 records.
namedTypesFilter: ["Company", "Supplier", "Part"],
idsFilter: ["{G4E8G2S8D-2GS5-98S4-3S5D-S1DE7G45DS48}",
"{FNWI1G5W-1A5W-3A5W-8412-A1W5F4W8F7AS}",
"{9D2D6AFD-41F1-49A4-8412-CACCC9906E88}"]
}
).then((streamingSearchResult)=>{
// the result of a streaming search is a readableStream which requires decoding.
readStream(streamingSearchResult)
})// a function to read the readable stream returned from the above query
const readStream = async (streamingQueryResult) => {
let time = Date.now();
let reader = streamingQueryResult.resultRowsStream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done) {
console.log(`Completed database requests: ${(Date.now() - time) / 1000} seconds`, value);
break;
}
console.log(`Chunk returned in: ${(Date.now() - time) / 1000} seconds`, value)
}
} catch (err) {
if (err.name === "AbortError") {
console.log("Request aborted as expected");
} else {
throw err;
}
}
};// sample result of streaming search result chunk read and printed to the console
"Streaming chunk returned in: 0.082 seconds"
[
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Suncommon",
"Employee_Count": 400,
"energyType": "solar"
},
"typeName": "Company",
"id": "{G4E8G2S8D-2GS5-98S4-3S5D-S1DE7G45DS48}"
}],
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Quality Solar Supply",
"Supplier_code": "158B",
"City": "New Orleans",
},
"typeName": "Supplier",
"id": "{FNWI1G5W-1A5W-3A5W-8412-A1W5F4W8F7AS}"
}],
[{
"declaredClass": "esri.rest.knowledgeGraph.Entity",
"properties": {
"Name": "Solar panel",
"panel_type": "Polycrystalline",
"price_per_unit": 400
},
"typeName": "Part",
"id": "{9D2D6AFD-41F1-49A4-8412-CACCC9906E88}"
}]
] executeUpdateGraphProperty(graph, namedType, originalPropertyName, updatedProperties, options){Promise<GraphUpdatePropertyResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeUpdateGraphProperty added at 4.33.
Update a GraphProperty for a particular entity type or relationship type in the graph.
Note
Parameters
The knowledge graph to update.
The name of the entity type or relationship type to update with the property to be updated.
The original name of the property to update.
The updated properties for the entity type or relationship type property specified.
optionalAdditional options to be used for the data request.
Returns
executeUpdateNamedType(graph, namedType, updatedNamedType, options){Promise<GraphUpdateNamedTypesResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeUpdateNamedType added at 4.33.
Parameters
The knowledge graph to update.
The name of the entity type or relationship type to update with the property to be updated.
The updated entity type or relationship type.
optionalAdditional options to be used for the data request.
Returns
executeUpdateSearchIndex(graph, namedType, searchProperties, options){Promise<GraphUpdateSearchIndexResult>}
Since: ArcGIS Maps SDK for JavaScript 4.33 knowledgeGraphService since 4.25, executeUpdateSearchIndex added at 4.33.
Parameters
The knowledge graph to update.
The name of the entity or relationship type to update.
The properties of the named type with which to update the search index.
Specification
The properties of the specified entity type or relationship type to add to the search index.
The properties of the specified entity type or relationship type to remove from the search index.
optionalAdditional options to be used for the data request.
Returns
fetchClientDataAtKeys(graph, keysToFetch, options){Promise<Map<string, string>>}
Retrieves the specified client data keys from the knowledge graph service associated with the given knowledge graph, if they exist. If a given client data key does not exist on the service, it is not returned in the result map.
Parameters
Specification
The knowledge graph associated with the service. See also ArcGIS REST APIs - Hosted Knowledge Graph Service.
An array of client data keys to fetch from the service
optionalAdditional options when requesting client keys.
Specification
optionalBy default, client data requests are cached by their version. When a previously requested key is requested again and the client data version for that key on the service is unchanged, the existing cached value is returned. When ignoreCache is true, the request ignores the cache and fetches and returns the value from the service.
Additional options to be used for the data request.
Returns
Type Description Promise<Map<string, string>> When resolved, the result is an array of the client data keys existing on the service at the time of the request.Example
// typical use case
const url = "https://myHostName.domain.com/server/rest/services/Hosted/myServiceName/KnowledgeGraphServer";
KnowledgeGraphModule.fetchClientDataAtKeys(url)
.then((clientDataResultMap) => {
// do something with result
}); fetchKnowledgeGraph(url){Promise<KnowledgeGraph>}
Retrieves the knowledge graph service based on the URL provided.
Returns
Example
// typical use case
const url = "https://myHostName.domain.com/server/rest/services/Hosted/myServiceName/KnowledgeGraphServer";
KnowledgeGraphModule.fetchKnowledgeGraph(url)
.then((kg) => {
// do something with result
}); refreshDataModel(graph)
Refreshes the data model of the knowledge graph.
Example
// typical use case
KnowledgeGraphModule.refreshDataModel(urlToKnowledgeGraph).then((newKG) => {
// do something with result
}); CIMFilteredFindPathsError Object
Errors returned in the result of executeFindPaths and executeFindPathsAsynchronous. When no path has been found, and CIMFilteredFindPathsResultJSON.configurationWarning is different from None, it is likely that the user made an unintended mistake in the configuration
"CIMFilteredFindPathsError"
The value is always "CIMFilteredFindPathsError".
Errors indicating why the tool could not be executed.
Possible Values:"None"|"ConfigurationHasTooManyInputEntities"|"ConfigurationIsTooComplex"|"PunctualEventHasNoTime"|"DurativeEventHasNoTime"|"DurativeEventHasOneMissingTime"|"DurativeEventHasSwappedTimes"
Details about the error.
CIMFilteredFindPathsResultJSON Object
The returned result of executeFindPaths and executeFindPathsAsynchronous.
The returned type of executeFindPaths and executeFindPathsAsynchronous.
The value is always "CIMFilteredFindPathsResult".
optionalAny errors encountered while executing filtered find path.
Warnings indicating why a path was not found.
Possible Values:"None"|"AllOriginsAreExcluded"|"AllDestinationsAreExcluded"|"AllOptionalWaypointsAreExcluded"|"AtLeastOneMandatoryEntityWaypointIsExcluded"|"AtLeastOneMandatoryRelationshipWaypointIsExcluded"|"ReachedMaxPathLength"
Pathfinding statistics.
The paths returned.
CIMFilteredFindPathsResultPaths Object
Represents the paths found by an executeFindPaths and executeFindPathsAsynchronous search.
We use a memory-optimized representation to avoid storing redundant information because it is often the case that a path shares some entities and relationships with many other paths, especially if the Filtered Find Paths configuration uses 'pathMode: "All"'.
Definition: a relationship group contains Knowledge Graph relationships associated to a single edge in the local graph.
Paths are encoded this way:
The path 'p' uses relationships groups pathsBuffer[pathsEndIndex[p-1] .. pathsEndIndex[p]], and:
A path of length zero (with entity 'e') has a single relationship group containing no relationship and where the origin and the destination are 'e'.
The relationships group 'g' has origin entitiesUIDs[relationshipsGroupsFrom[g]] and destination entitiesUIDs[RelationshipsGroupsTo[g]]. Its relationships are relationshipsGroupsUIDsBuffer[relationshipsGroupsUIDsEndIndex[g-1] .. relationshipsGroupsUIDsEndIndex[g]].
If relationshipsFrom[i] >= 0, relationship relationshipsGroupsUIDsBuffer[i] has origin entitiesUIDs[relationshipsFrom[i]] otherwise the relationship has been deleted after pathfinding.
If relationshipsTo[i] >= 0, relationship relationshipsGroupsUIDsBuffer[i] has destination entitiesUIDs[relationshipsTo[i]] otherwise the relationship has been deleted after pathfinding.
Note that origin and destination of a relationship may not match origin and destination of the relationship group because the relationship can be traversed backwards.
"CIMKGPaths"
The value is always "CIMKGPaths".
optionalThe list of entities that may be used in paths (not all entities are guaranteed to be used).
optionalA list parallel to EntitiesUIDs representing entity type indices. If EntityTypes[i] >= 0, EntitiesUIDs[i] has type IndexedEntityTypes[EntityTypes[i]], otherwise the entity has been deleted after the find path operation.
optionalThe list of entity types, indexed by entityTypes
The list of relationships that may be used in paths (not all relationships are guaranteed to be used). The list may contain duplicate elements.
optionalA list parallel to RelationshipsGroupsUIDsBuffer representing relationship type indices. If RelationshipTypes[i] >= 0, RelationshipsGroupsUIDsBuffer[i] has type IndexedRelationshipTypes[RelationshipTypes[i]], otherwise the relationship has been deleted after the find path operation.
The list of relationship types, indexed by relationshipTypes
The list of relationship group's relationship end indices (indexes into relationshipsGroupsUIDsBuffer). Values must be positive.
The list of relationship group's origin entity index (indexes into entitiesUIDs). Values must be positive.
The list of relationship group's destination entity index (indexes into entitiesUIDs). Values must be positive.
The list of relationship's origin entity index (indexes into entitiesUIDs).
The list of relationships destination entity index (indexes into entitiesUIDs).
List of relationships groups indices used by paths. Values must be positive.
optionalList of paths relationships groups end indices (indexes into 'PathsBuffer'). Values must be positive.
CIMFilteredFindPathsStatistics Object
Represents the statistics related to an executeFindPaths or executeFindPathsAsynchronous search. It contains the size of the local graph, and the number of openCypher "expansion" queries that have been issued to construct the local graph.
The local graph is an in-memory graph used for pathfinding where a node represents an entity in the Knowledge Graph and an edge represents one or many parallel relationships in the Knowledge Graph.
The local graph typically contains (much) less nodes than the Knowledge Graph, but enough nodes and edges to ensure that the pathfinding results are accurate. For example, to guarantee that all paths of length up to 'L' between 'A' and 'B' are present in the local graph, we ensure that the sum of counts of "expansion" queries related to 'A' and 'B' is greater or equal to 'L'.
"CIMFilteredFindPathsStatistics"
The value is always "CIMFilteredFindPathsStatistics".
optionalNumber of nodes found in the local graph.
optionalNumber of edges in the local graph. One edge in the local graph may represent multiple relationships when these relationships are parallel and equivalent with regard to pathfinding
countOriginExpansionQueries Number optionalGets or sets the count of expansion queries that were done to discover the neighborhood of some origin entities.
countDestinationExpansionQueries Number optionalGets or sets the count of expansion queries that were done to discover the neighborhood of some destination entities.
countWaypointsExpansionQueries Number optionalGets or sets the count of expansion queries that were done to discover the neighborhood of entity or relationship waypoints.
UpdateGraphProperties Object
The properties of a GraphProperty that can be updated with executeUpdateGraphProperty
The display name of the graph property.
optionalIf users are allowed to edit the property.
optionalIf the property is required when a new record of that entity type or relationship type is created.
optionalIf the property is visible by default.
optionalThe default value of the property.
UpdateNamedType Object
Properties of a named type that can be updated, such as the alias.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4