GraphScope Interactive API v0.3

API and SDK Documentation

Version: 1.0.0

This is the definition of GraphScope Interactive API, including

AdminService API
Vertex/Edge API
QueryService

AdminService API (with tag AdminService) defines the API for GraphManagement, ProcedureManagement and Service Management.

Vertex/Edge API (with tag GraphService) defines the API for Vertex/Edge management, including creation/updating/delete/retrieve.

QueryService API (with tag QueryService) defines the API for procedure_call, Ahodc query.

AdminServiceGraphManagement

createDataloadingJob

Create a dataloading job

/v1/graph/{graph_id}/dataloading

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/dataloading" \
 -d '{
  "loading_config" : {
    "x_csr_params" : {
      "parallelism" : 7,
      "build_csr_in_mem" : true,
      "use_mmap_vector" : true
    },
    "format" : {
      "metadata" : {
        "key" : ""
      },
      "type" : "type"
    },
    "destination" : "destination",
    "import_option" : "init",
    "data_source" : {
      "scheme" : "odps",
      "location" : "location"
    }
  },
  "edge_mappings" : [ {
    "inputs" : [ "inputs", "inputs" ],
    "source_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    } ],
    "destination_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    } ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    } ],
    "type_triplet" : {
      "edge" : "edge",
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex"
    }
  }, {
    "inputs" : [ "inputs", "inputs" ],
    "source_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    } ],
    "destination_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "id"
    } ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    } ],
    "type_triplet" : {
      "edge" : "edge",
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex"
    }
  } ],
  "vertex_mappings" : [ {
    "type_name" : "type_name",
    "inputs" : [ "file:///path/to/person.csv", "file:///path/to/person.csv" ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    } ]
  }, {
    "type_name" : "type_name",
    "inputs" : [ "file:///path/to/person.csv", "file:///path/to/person.csv" ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 9
      },
      "property" : "property"
    } ]
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to do bulk loading.
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createDataloadingJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to do bulk loading.
final SchemaMapping schemaMapping = new SchemaMapping(); // SchemaMapping | 

try {
    final result = await api_instance.createDataloadingJob(graphId, schemaMapping);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createDataloadingJob: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to do bulk loading.
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createDataloadingJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to do bulk loading. (default to null)
SchemaMapping *schemaMapping = ; // 

[apiInstance createDataloadingJobWith:graphId
    schemaMapping:schemaMapping
              completionHandler: ^(JobResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to do bulk loading.
var schemaMapping = ; // {SchemaMapping} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createDataloadingJob(graphId, schemaMapping, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createDataloadingJobExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to do bulk loading. (default to null)
            var schemaMapping = new SchemaMapping(); // SchemaMapping | 

            try {
                JobResponse result = apiInstance.createDataloadingJob(graphId, schemaMapping);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createDataloadingJob: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to do bulk loading.
$schemaMapping = ; // SchemaMapping | 

try {
    $result = $api_instance->createDataloadingJob($graphId, $schemaMapping);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createDataloadingJob: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to do bulk loading.
my $schemaMapping = WWW::OPenAPIClient::Object::SchemaMapping->new(); # SchemaMapping | 

eval {
    my $result = $api_instance->createDataloadingJob(graphId => $graphId, schemaMapping => $schemaMapping);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createDataloadingJob: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to do bulk loading. (default to null)
schemaMapping =  # SchemaMapping | 

try:
    api_response = api_instance.create_dataloading_job(graphId, schemaMapping)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createDataloadingJob: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let schemaMapping = ; // SchemaMapping

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createDataloadingJob(graphId, schemaMapping, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of graph to do bulk loading. Required

Body parameters

Name	Description
schemaMapping *

Responses

Schema

createEdgeType

Create a edge type

/v1/graph/{graph_id}/schema/edge

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/edge" \
 -d '{
  "type_name" : "type_name",
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "vertex_type_pair_relations" : [ {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN",
      "ie_mutability" : "ie_mutability",
      "sort_on_compaction" : true,
      "oe_mutability" : "oe_mutability"
    },
    "relation" : "MANY_TO_MANY"
  }, {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN",
      "ie_mutability" : "ie_mutability",
      "sort_on_compaction" : true,
      "oe_mutability" : "oe_mutability"
    },
    "relation" : "MANY_TO_MANY"
  } ],
  "properties" : [ {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  }, {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createEdgeType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateEdgeType createEdgeType = new CreateEdgeType(); // CreateEdgeType | 

try {
    final result = await api_instance.createEdgeType(graphId, createEdgeType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createEdgeType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createEdgeType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateEdgeType *createEdgeType = ; //  (optional)

[apiInstance createEdgeTypeWith:graphId
    createEdgeType:createEdgeType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var opts = {
  'createEdgeType':  // {CreateEdgeType} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createEdgeType(graphId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createEdgeTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createEdgeType = new CreateEdgeType(); // CreateEdgeType |  (optional) 

            try {
                'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createEdgeType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$createEdgeType = ; // CreateEdgeType | 

try {
    $result = $api_instance->createEdgeType($graphId, $createEdgeType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createEdgeType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $createEdgeType = WWW::OPenAPIClient::Object::CreateEdgeType->new(); # CreateEdgeType | 

eval {
    my $result = $api_instance->createEdgeType(graphId => $graphId, createEdgeType => $createEdgeType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createEdgeType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
createEdgeType =  # CreateEdgeType |  (optional)

try:
    api_response = api_instance.create_edge_type(graphId, createEdgeType=createEdgeType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createEdgeType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createEdgeType = ; // CreateEdgeType

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createEdgeType(graphId, createEdgeType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createEdgeType

Responses

Schema

Schema

Schema

createGraph

Create a new graph

/v1/graph

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph" \
 -d '{
  "schema" : {
    "vertex_types" : [ {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "x_csr_params" : {
        "max_vertex_num" : 1
      },
      "properties" : [ {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      }, {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      } ]
    }, {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "x_csr_params" : {
        "max_vertex_num" : 1
      },
      "properties" : [ {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      }, {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      } ]
    } ],
    "edge_types" : [ {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "vertex_type_pair_relations" : [ {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN",
          "ie_mutability" : "ie_mutability",
          "sort_on_compaction" : true,
          "oe_mutability" : "oe_mutability"
        },
        "relation" : "MANY_TO_MANY"
      }, {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN",
          "ie_mutability" : "ie_mutability",
          "sort_on_compaction" : true,
          "oe_mutability" : "oe_mutability"
        },
        "relation" : "MANY_TO_MANY"
      } ],
      "properties" : [ {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      }, {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      } ]
    }, {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "vertex_type_pair_relations" : [ {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN",
          "ie_mutability" : "ie_mutability",
          "sort_on_compaction" : true,
          "oe_mutability" : "oe_mutability"
        },
        "relation" : "MANY_TO_MANY"
      }, {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN",
          "ie_mutability" : "ie_mutability",
          "sort_on_compaction" : true,
          "oe_mutability" : "oe_mutability"
        },
        "relation" : "MANY_TO_MANY"
      } ],
      "properties" : [ {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      }, {
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "property_name" : "property_name"
      } ]
    } ]
  },
  "stored_procedures" : [ {
    "query" : "MATCH(a) return COUNT(a);",
    "name" : "query1",
    "description" : "A sample stored procedure",
    "type" : "cpp"
  }, {
    "query" : "MATCH(a) return COUNT(a);",
    "name" : "query1",
    "description" : "A sample stored procedure",
    "type" : "cpp"
  } ],
  "name" : "modern_graph",
  "description" : "A default description"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

        try {
            CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateGraphRequest createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

try {
    final result = await api_instance.createGraph(createGraphRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createGraph: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

        try {
            CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createGraph");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
CreateGraphRequest *createGraphRequest = ; // 

[apiInstance createGraphWith:createGraphRequest
              completionHandler: ^(CreateGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var createGraphRequest = ; // {CreateGraphRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGraph(createGraphRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createGraphExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

            try {
                CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createGraph: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$createGraphRequest = ; // CreateGraphRequest | 

try {
    $result = $api_instance->createGraph($createGraphRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createGraph: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $createGraphRequest = WWW::OPenAPIClient::Object::CreateGraphRequest->new(); # CreateGraphRequest | 

eval {
    my $result = $api_instance->createGraph(createGraphRequest => $createGraphRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createGraph: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
createGraphRequest =  # CreateGraphRequest | 

try:
    api_response = api_instance.create_graph(createGraphRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let createGraphRequest = ; // CreateGraphRequest

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createGraph(createGraphRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
createGraphRequest *

Responses

Schema

Schema

Schema

createVertexType

Create a vertex type

/v1/graph/{graph_id}/schema/vertex

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/vertex" \
 -d '{
  "type_name" : "type_name",
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "x_csr_params" : {
    "max_vertex_num" : 1
  },
  "properties" : [ {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  }, {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.createVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createVertexType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateVertexType createVertexType = new CreateVertexType(); // CreateVertexType | 

try {
    final result = await api_instance.createVertexType(graphId, createVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createVertexType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.createVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#createVertexType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateVertexType *createVertexType = ; // 

[apiInstance createVertexTypeWith:graphId
    createVertexType:createVertexType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var createVertexType = ; // {CreateVertexType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createVertexType(graphId, createVertexType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createVertexTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createVertexType = new CreateVertexType(); // CreateVertexType | 

            try {
                'String' result = apiInstance.createVertexType(graphId, createVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.createVertexType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$createVertexType = ; // CreateVertexType | 

try {
    $result = $api_instance->createVertexType($graphId, $createVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->createVertexType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $createVertexType = WWW::OPenAPIClient::Object::CreateVertexType->new(); # CreateVertexType | 

eval {
    my $result = $api_instance->createVertexType(graphId => $graphId, createVertexType => $createVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->createVertexType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
createVertexType =  # CreateVertexType | 

try:
    api_response = api_instance.create_vertex_type(graphId, createVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->createVertexType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createVertexType = ; // CreateVertexType

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.createVertexType(graphId, createVertexType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createVertexType *

Responses

Schema

Schema

Schema

deleteEdgeType

Delete an edge type by name

/v1/graph/{graph_id}/schema/edge

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/edge?type_name=typeName_example&source_vertex_type=sourceVertexType_example&destination_vertex_type=destinationVertexType_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteEdgeType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 
final String sourceVertexType = new String(); // String | 
final String destinationVertexType = new String(); // String | 

try {
    final result = await api_instance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEdgeType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteEdgeType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)
String *sourceVertexType = sourceVertexType_example; //  (default to null)
String *destinationVertexType = destinationVertexType_example; //  (default to null)

[apiInstance deleteEdgeTypeWith:graphId
    typeName:typeName
    sourceVertexType:sourceVertexType
    destinationVertexType:destinationVertexType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 
var sourceVertexType = sourceVertexType_example; // {String} 
var destinationVertexType = destinationVertexType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteEdgeTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)
            var sourceVertexType = sourceVertexType_example;  // String |  (default to null)
            var destinationVertexType = destinationVertexType_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteEdgeType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 
$sourceVertexType = sourceVertexType_example; // String | 
$destinationVertexType = destinationVertexType_example; // String | 

try {
    $result = $api_instance->deleteEdgeType($graphId, $typeName, $sourceVertexType, $destinationVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 
my $sourceVertexType = sourceVertexType_example; # String | 
my $destinationVertexType = destinationVertexType_example; # String | 

eval {
    my $result = $api_instance->deleteEdgeType(graphId => $graphId, typeName => $typeName, sourceVertexType => $sourceVertexType, destinationVertexType => $destinationVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)
sourceVertexType = sourceVertexType_example # String |  (default to null)
destinationVertexType = destinationVertexType_example # String |  (default to null)

try:
    api_response = api_instance.delete_edge_type(graphId, typeName, sourceVertexType, destinationVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->deleteEdgeType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String
    let sourceVertexType = sourceVertexType_example; // String
    let destinationVertexType = destinationVertexType_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteEdgeType(graphId, typeName, sourceVertexType, destinationVertexType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Query parameters

Name	Description
type_name*	String Required
source_vertex_type*	String Required
destination_vertex_type*	String Required

Responses

Schema

Schema

Schema

deleteGraph

Delete a graph by id

/v1/graph/{graph_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            'String' result = apiInstance.deleteGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to delete

try {
    final result = await api_instance.deleteGraph(graphId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteGraph: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to delete

        try {
            'String' result = apiInstance.deleteGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteGraph");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to delete (default to null)

[apiInstance deleteGraphWith:graphId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to delete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteGraph(graphId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteGraphExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to delete (default to null)

            try {
                'String' result = apiInstance.deleteGraph(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteGraph: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to delete

try {
    $result = $api_instance->deleteGraph($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->deleteGraph: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to delete

eval {
    my $result = $api_instance->deleteGraph(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->deleteGraph: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to delete (default to null)

try:
    api_response = api_instance.delete_graph(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->deleteGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteGraph(graphId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of graph to delete Required

Responses

Schema

Schema

Schema

deleteVertexType

Delete a vertex type by name

/v1/graph/{graph_id}/schema/vertex

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/vertex?type_name=typeName_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.deleteVertexType(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteVertexType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 

try {
    final result = await api_instance.deleteVertexType(graphId, typeName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteVertexType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.deleteVertexType(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#deleteVertexType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)

[apiInstance deleteVertexTypeWith:graphId
    typeName:typeName
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteVertexType(graphId, typeName, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteVertexTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteVertexType(graphId, typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.deleteVertexType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 

try {
    $result = $api_instance->deleteVertexType($graphId, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->deleteVertexType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 

eval {
    my $result = $api_instance->deleteVertexType(graphId => $graphId, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->deleteVertexType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)

try:
    api_response = api_instance.delete_vertex_type(graphId, typeName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->deleteVertexType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.deleteVertexType(graphId, typeName, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Query parameters

Name	Description
type_name*	String Required

Responses

Schema

Schema

Schema

getGraph

Get a graph by name

/v1/graph/{graph_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get

        try {
            GetGraphResponse result = apiInstance.getGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to get

try {
    final result = await api_instance.getGraph(graphId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getGraph: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get

        try {
            GetGraphResponse result = apiInstance.getGraph(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraph");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to get (default to null)

[apiInstance getGraphWith:graphId
              completionHandler: ^(GetGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to get

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGraph(graphId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGraphExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to get (default to null)

            try {
                GetGraphResponse result = apiInstance.getGraph(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getGraph: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to get

try {
    $result = $api_instance->getGraph($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->getGraph: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to get

eval {
    my $result = $api_instance->getGraph(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->getGraph: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to get (default to null)

try:
    api_response = api_instance.get_graph(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getGraph: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getGraph(graphId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of graph to get Required

Responses

Schema

Schema

getGraphStatistic

Get the statics info of a graph, including number of vertices for each label, number of edges for each label.

/v1/graph/{graph_id}/statistics

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/statistics"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get statistics

        try {
            GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraphStatistic");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to get statistics

try {
    final result = await api_instance.getGraphStatistic(graphId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getGraphStatistic: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get statistics

        try {
            GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getGraphStatistic");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to get statistics (default to null)

[apiInstance getGraphStatisticWith:graphId
              completionHandler: ^(GetGraphStatisticsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to get statistics

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGraphStatistic(graphId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGraphStatisticExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to get statistics (default to null)

            try {
                GetGraphStatisticsResponse result = apiInstance.getGraphStatistic(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getGraphStatistic: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to get statistics

try {
    $result = $api_instance->getGraphStatistic($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->getGraphStatistic: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to get statistics

eval {
    my $result = $api_instance->getGraphStatistic(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->getGraphStatistic: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to get statistics (default to null)

try:
    api_response = api_instance.get_graph_statistic(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getGraphStatistic: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getGraphStatistic(graphId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of graph to get statistics Required

Responses

Schema

Schema

Schema

Schema

getSchema

Get schema by graph id

/v1/graph/{graph_id}/schema

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get schema

        try {
            GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSchema");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of graph to get schema

try {
    final result = await api_instance.getSchema(graphId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSchema: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | The id of graph to get schema

        try {
            GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSchema");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; // The id of graph to get schema (default to null)

[apiInstance getSchemaWith:graphId
              completionHandler: ^(GetGraphSchemaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} The id of graph to get schema

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchema(graphId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSchemaExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String | The id of graph to get schema (default to null)

            try {
                GetGraphSchemaResponse result = apiInstance.getSchema(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getSchema: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | The id of graph to get schema

try {
    $result = $api_instance->getSchema($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->getSchema: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | The id of graph to get schema

eval {
    my $result = $api_instance->getSchema(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->getSchema: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String | The id of graph to get schema (default to null)

try:
    api_response = api_instance.get_schema(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getSchema: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getSchema(graphId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of graph to get schema Required

Responses

Schema

Schema

getSnapshotStatus

Get the status of a snapshot by id

/v1/graph/{graph_id}/snapshot/{snapshot_id}/status

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/snapshot/{snapshot_id}/status"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        Integer snapshotId = 56; // Integer | 

        try {
            SnapshotStatus result = apiInstance.getSnapshotStatus(graphId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSnapshotStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final Integer snapshotId = new Integer(); // Integer | 

try {
    final result = await api_instance.getSnapshotStatus(graphId, snapshotId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSnapshotStatus: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        Integer snapshotId = 56; // Integer | 

        try {
            SnapshotStatus result = apiInstance.getSnapshotStatus(graphId, snapshotId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#getSnapshotStatus");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
Integer *snapshotId = 56; //  (default to null)

[apiInstance getSnapshotStatusWith:graphId
    snapshotId:snapshotId
              completionHandler: ^(SnapshotStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var snapshotId = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSnapshotStatus(graphId, snapshotId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSnapshotStatusExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var snapshotId = 56;  // Integer |  (default to null)

            try {
                SnapshotStatus result = apiInstance.getSnapshotStatus(graphId, snapshotId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.getSnapshotStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$snapshotId = 56; // Integer | 

try {
    $result = $api_instance->getSnapshotStatus($graphId, $snapshotId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->getSnapshotStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $snapshotId = 56; # Integer | 

eval {
    my $result = $api_instance->getSnapshotStatus(graphId => $graphId, snapshotId => $snapshotId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->getSnapshotStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
snapshotId = 56 # Integer |  (default to null)

try:
    api_response = api_instance.get_snapshot_status(graphId, snapshotId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->getSnapshotStatus: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let snapshotId = 56; // Integer

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.getSnapshotStatus(graphId, snapshotId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
snapshot_id*	Integer Required

Responses

Schema

Schema

Schema

listGraphs

List all graphs

/v1/graph

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();

        try {
            array[GetGraphResponse] result = apiInstance.listGraphs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#listGraphs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listGraphs();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listGraphs: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();

        try {
            array[GetGraphResponse] result = apiInstance.listGraphs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#listGraphs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];

[apiInstance listGraphsWithCompletionHandler: 
              ^(array[GetGraphResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listGraphs(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class listGraphsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();

            try {
                array[GetGraphResponse] result = apiInstance.listGraphs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.listGraphs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();

try {
    $result = $api_instance->listGraphs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->listGraphs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();

eval {
    my $result = $api_instance->listGraphs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->listGraphs: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()

try:
    api_response = api_instance.list_graphs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->listGraphs: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.listGraphs(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

updateEdgeType

Update an edge type to add more properties

/v1/graph/{graph_id}/schema/edge

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/edge" \
 -d '{
  "type_name" : "type_name",
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "vertex_type_pair_relations" : [ {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN",
      "ie_mutability" : "ie_mutability",
      "sort_on_compaction" : true,
      "oe_mutability" : "oe_mutability"
    },
    "relation" : "MANY_TO_MANY"
  }, {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN",
      "ie_mutability" : "ie_mutability",
      "sort_on_compaction" : true,
      "oe_mutability" : "oe_mutability"
    },
    "relation" : "MANY_TO_MANY"
  } ],
  "properties" : [ {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  }, {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.updateEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#updateEdgeType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateEdgeType createEdgeType = new CreateEdgeType(); // CreateEdgeType | 

try {
    final result = await api_instance.updateEdgeType(graphId, createEdgeType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateEdgeType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.updateEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#updateEdgeType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateEdgeType *createEdgeType = ; // 

[apiInstance updateEdgeTypeWith:graphId
    createEdgeType:createEdgeType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var createEdgeType = ; // {CreateEdgeType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateEdgeType(graphId, createEdgeType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateEdgeTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createEdgeType = new CreateEdgeType(); // CreateEdgeType | 

            try {
                'String' result = apiInstance.updateEdgeType(graphId, createEdgeType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.updateEdgeType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$createEdgeType = ; // CreateEdgeType | 

try {
    $result = $api_instance->updateEdgeType($graphId, $createEdgeType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->updateEdgeType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $createEdgeType = WWW::OPenAPIClient::Object::CreateEdgeType->new(); # CreateEdgeType | 

eval {
    my $result = $api_instance->updateEdgeType(graphId => $graphId, createEdgeType => $createEdgeType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->updateEdgeType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
createEdgeType =  # CreateEdgeType | 

try:
    api_response = api_instance.update_edge_type(graphId, createEdgeType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->updateEdgeType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createEdgeType = ; // CreateEdgeType

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.updateEdgeType(graphId, createEdgeType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createEdgeType *

Responses

Schema

Schema

Schema

updateVertexType

Update a vertex type to add more properties

/v1/graph/{graph_id}/schema/vertex

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/schema/vertex" \
 -d '{
  "type_name" : "type_name",
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "x_csr_params" : {
    "max_vertex_num" : 1
  },
  "properties" : [ {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  }, {
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "property_name" : "property_name"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceGraphManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.updateVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#updateVertexType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateVertexType createVertexType = new CreateVertexType(); // CreateVertexType | 

try {
    final result = await api_instance.updateVertexType(graphId, createVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateVertexType: $e\n');
}

import org.openapitools.client.api.AdminServiceGraphManagementApi;

public class AdminServiceGraphManagementApiExample {
    public static void main(String[] args) {
        AdminServiceGraphManagementApi apiInstance = new AdminServiceGraphManagementApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.updateVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceGraphManagementApi#updateVertexType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceGraphManagementApi *apiInstance = [[AdminServiceGraphManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateVertexType *createVertexType = ; // 

[apiInstance updateVertexTypeWith:graphId
    createVertexType:createVertexType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceGraphManagementApi()
var graphId = graphId_example; // {String} 
var createVertexType = ; // {CreateVertexType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateVertexType(graphId, createVertexType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateVertexTypeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceGraphManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createVertexType = new CreateVertexType(); // CreateVertexType | 

            try {
                'String' result = apiInstance.updateVertexType(graphId, createVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceGraphManagementApi.updateVertexType: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceGraphManagementApi();
$graphId = graphId_example; // String | 
$createVertexType = ; // CreateVertexType | 

try {
    $result = $api_instance->updateVertexType($graphId, $createVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceGraphManagementApi->updateVertexType: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceGraphManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceGraphManagementApi->new();
my $graphId = graphId_example; # String | 
my $createVertexType = WWW::OPenAPIClient::Object::CreateVertexType->new(); # CreateVertexType | 

eval {
    my $result = $api_instance->updateVertexType(graphId => $graphId, createVertexType => $createVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceGraphManagementApi->updateVertexType: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceGraphManagementApi()
graphId = graphId_example # String |  (default to null)
createVertexType =  # CreateVertexType | 

try:
    api_response = api_instance.update_vertex_type(graphId, createVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceGraphManagementApi->updateVertexType: %s\n" % e)

extern crate AdminServiceGraphManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createVertexType = ; // CreateVertexType

    let mut context = AdminServiceGraphManagementApi::Context::default();
    let result = client.updateVertexType(graphId, createVertexType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createVertexType *

Responses

Schema

Schema

Schema

AdminServiceJobManagement

deleteJobById

/v1/job/{job_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/v1/job/{job_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceJobManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | 

        try {
            'String' result = apiInstance.deleteJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#deleteJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 

try {
    final result = await api_instance.deleteJobById(jobId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteJobById: $e\n');
}

import org.openapitools.client.api.AdminServiceJobManagementApi;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | 

        try {
            'String' result = apiInstance.deleteJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#deleteJobById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceJobManagementApi *apiInstance = [[AdminServiceJobManagementApi alloc] init];
String *jobId = jobId_example; //  (default to null)

[apiInstance deleteJobByIdWith:jobId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceJobManagementApi()
var jobId = jobId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteJobById(jobId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteJobByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceJobManagementApi();
            var jobId = jobId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteJobById(jobId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.deleteJobById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceJobManagementApi();
$jobId = jobId_example; // String | 

try {
    $result = $api_instance->deleteJobById($jobId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceJobManagementApi->deleteJobById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceJobManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceJobManagementApi->new();
my $jobId = jobId_example; # String | 

eval {
    my $result = $api_instance->deleteJobById(jobId => $jobId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceJobManagementApi->deleteJobById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceJobManagementApi()
jobId = jobId_example # String |  (default to null)

try:
    api_response = api_instance.delete_job_by_id(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceJobManagementApi->deleteJobById: %s\n" % e)

extern crate AdminServiceJobManagementApi;

pub fn main() {
    let jobId = jobId_example; // String

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.deleteJobById(jobId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
job_id*	String Required

Responses

Schema

getJobById

/v1/job/{job_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/job/{job_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceJobManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#getJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

try {
    final result = await api_instance.getJobById(jobId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getJobById: $e\n');
}

import org.openapitools.client.api.AdminServiceJobManagementApi;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();
        String jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#getJobById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceJobManagementApi *apiInstance = [[AdminServiceJobManagementApi alloc] init];
String *jobId = jobId_example; // The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

[apiInstance getJobByIdWith:jobId
              completionHandler: ^(JobStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceJobManagementApi()
var jobId = jobId_example; // {String} The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getJobById(jobId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getJobByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceJobManagementApi();
            var jobId = jobId_example;  // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

            try {
                JobStatus result = apiInstance.getJobById(jobId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.getJobById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceJobManagementApi();
$jobId = jobId_example; // String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

try {
    $result = $api_instance->getJobById($jobId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceJobManagementApi->getJobById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceJobManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceJobManagementApi->new();
my $jobId = jobId_example; # String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading

eval {
    my $result = $api_instance->getJobById(jobId => $jobId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceJobManagementApi->getJobById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceJobManagementApi()
jobId = jobId_example # String | The id of the job, returned from POST /v1/graph/{graph_id}/dataloading (default to null)

try:
    api_response = api_instance.get_job_by_id(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceJobManagementApi->getJobById: %s\n" % e)

extern crate AdminServiceJobManagementApi;

pub fn main() {
    let jobId = jobId_example; // String

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.getJobById(jobId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
job_id*	String The id of the job, returned from POST /v1/graph/{graph_id}/dataloading Required

Responses

Schema

listJobs

/v1/job

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/job"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceJobManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();

        try {
            array[JobStatus] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#listJobs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listJobs();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listJobs: $e\n');
}

import org.openapitools.client.api.AdminServiceJobManagementApi;

public class AdminServiceJobManagementApiExample {
    public static void main(String[] args) {
        AdminServiceJobManagementApi apiInstance = new AdminServiceJobManagementApi();

        try {
            array[JobStatus] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceJobManagementApi#listJobs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceJobManagementApi *apiInstance = [[AdminServiceJobManagementApi alloc] init];

[apiInstance listJobsWithCompletionHandler: 
              ^(array[JobStatus] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceJobManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listJobs(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class listJobsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceJobManagementApi();

            try {
                array[JobStatus] result = apiInstance.listJobs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceJobManagementApi.listJobs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceJobManagementApi();

try {
    $result = $api_instance->listJobs();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceJobManagementApi->listJobs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceJobManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceJobManagementApi->new();

eval {
    my $result = $api_instance->listJobs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceJobManagementApi->listJobs: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceJobManagementApi()

try:
    api_response = api_instance.list_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceJobManagementApi->listJobs: %s\n" % e)

extern crate AdminServiceJobManagementApi;

pub fn main() {

    let mut context = AdminServiceJobManagementApi::Context::default();
    let result = client.listJobs(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

AdminServiceProcedureManagement

createProcedure

Create a new procedure on a graph

/v1/graph/{graph_id}/procedure

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/procedure" \
 -d '{
  "query" : "MATCH(a) return COUNT(a);",
  "name" : "query1",
  "description" : "A sample stored procedure",
  "type" : "cpp"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceProcedureManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        CreateProcedureRequest createProcedureRequest = ; // CreateProcedureRequest | 

        try {
            CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#createProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateProcedureRequest createProcedureRequest = new CreateProcedureRequest(); // CreateProcedureRequest | 

try {
    final result = await api_instance.createProcedure(graphId, createProcedureRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createProcedure: $e\n');
}

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        CreateProcedureRequest createProcedureRequest = ; // CreateProcedureRequest | 

        try {
            CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#createProcedure");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateProcedureRequest *createProcedureRequest = ; // 

[apiInstance createProcedureWith:graphId
    createProcedureRequest:createProcedureRequest
              completionHandler: ^(CreateProcedureResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var createProcedureRequest = ; // {CreateProcedureRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProcedure(graphId, createProcedureRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createProcedureExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createProcedureRequest = new CreateProcedureRequest(); // CreateProcedureRequest | 

            try {
                CreateProcedureResponse result = apiInstance.createProcedure(graphId, createProcedureRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.createProcedure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$createProcedureRequest = ; // CreateProcedureRequest | 

try {
    $result = $api_instance->createProcedure($graphId, $createProcedureRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->createProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceProcedureManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $createProcedureRequest = WWW::OPenAPIClient::Object::CreateProcedureRequest->new(); # CreateProcedureRequest | 

eval {
    my $result = $api_instance->createProcedure(graphId => $graphId, createProcedureRequest => $createProcedureRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->createProcedure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
createProcedureRequest =  # CreateProcedureRequest | 

try:
    api_response = api_instance.create_procedure(graphId, createProcedureRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->createProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createProcedureRequest = ; // CreateProcedureRequest

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.createProcedure(graphId, createProcedureRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createProcedureRequest *

Responses

Schema

Schema

Schema

Schema

deleteProcedure

Delete a procedure on a graph by id

/v1/graph/{graph_id}/procedure/{procedure_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/procedure/{procedure_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceProcedureManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#deleteProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 

try {
    final result = await api_instance.deleteProcedure(graphId, procedureId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteProcedure: $e\n');
}

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#deleteProcedure");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)

[apiInstance deleteProcedureWith:graphId
    procedureId:procedureId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProcedure(graphId, procedureId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteProcedureExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteProcedure(graphId, procedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.deleteProcedure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 

try {
    $result = $api_instance->deleteProcedure($graphId, $procedureId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->deleteProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceProcedureManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 

eval {
    my $result = $api_instance->deleteProcedure(graphId => $graphId, procedureId => $procedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->deleteProcedure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)

try:
    api_response = api_instance.delete_procedure(graphId, procedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->deleteProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.deleteProcedure(graphId, procedureId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
procedure_id*	String Required

Responses

Schema

Schema

getProcedure

Get a procedure by id

/v1/graph/{graph_id}/procedure/{procedure_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/procedure/{procedure_id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceProcedureManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#getProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 

try {
    final result = await api_instance.getProcedure(graphId, procedureId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getProcedure: $e\n');
}

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 

        try {
            GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#getProcedure");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)

[apiInstance getProcedureWith:graphId
    procedureId:procedureId
              completionHandler: ^(GetProcedureResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcedure(graphId, procedureId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getProcedureExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)

            try {
                GetProcedureResponse result = apiInstance.getProcedure(graphId, procedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.getProcedure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 

try {
    $result = $api_instance->getProcedure($graphId, $procedureId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->getProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceProcedureManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 

eval {
    my $result = $api_instance->getProcedure(graphId => $graphId, procedureId => $procedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->getProcedure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)

try:
    api_response = api_instance.get_procedure(graphId, procedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->getProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.getProcedure(graphId, procedureId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
procedure_id*	String Required

Responses

Schema

Schema

listProcedures

List all procedures

/v1/graph/{graph_id}/procedure

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/procedure"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceProcedureManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#listProcedures");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 

try {
    final result = await api_instance.listProcedures(graphId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listProcedures: $e\n');
}

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#listProcedures");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance listProceduresWith:graphId
              completionHandler: ^(array[GetProcedureResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listProcedures(graphId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class listProceduresExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                array[GetProcedureResponse] result = apiInstance.listProcedures(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.listProcedures: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->listProcedures($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->listProcedures: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceProcedureManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->listProcedures(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->listProcedures: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.list_procedures(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->listProcedures: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.listProcedures(graphId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

updateProcedure

Update procedure on a graph by id

/v1/graph/{graph_id}/procedure/{procedure_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/procedure/{procedure_id}" \
 -d '{
  "description" : "A sample stored procedure"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceProcedureManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 
        UpdateProcedureRequest updateProcedureRequest = ; // UpdateProcedureRequest | 

        try {
            'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#updateProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String procedureId = new String(); // String | 
final UpdateProcedureRequest updateProcedureRequest = new UpdateProcedureRequest(); // UpdateProcedureRequest | 

try {
    final result = await api_instance.updateProcedure(graphId, procedureId, updateProcedureRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateProcedure: $e\n');
}

import org.openapitools.client.api.AdminServiceProcedureManagementApi;

public class AdminServiceProcedureManagementApiExample {
    public static void main(String[] args) {
        AdminServiceProcedureManagementApi apiInstance = new AdminServiceProcedureManagementApi();
        String graphId = graphId_example; // String | 
        String procedureId = procedureId_example; // String | 
        UpdateProcedureRequest updateProcedureRequest = ; // UpdateProcedureRequest | 

        try {
            'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceProcedureManagementApi#updateProcedure");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceProcedureManagementApi *apiInstance = [[AdminServiceProcedureManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *procedureId = procedureId_example; //  (default to null)
UpdateProcedureRequest *updateProcedureRequest = ; //  (optional)

[apiInstance updateProcedureWith:graphId
    procedureId:procedureId
    updateProcedureRequest:updateProcedureRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceProcedureManagementApi()
var graphId = graphId_example; // {String} 
var procedureId = procedureId_example; // {String} 
var opts = {
  'updateProcedureRequest':  // {UpdateProcedureRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateProcedure(graphId, procedureId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateProcedureExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceProcedureManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var procedureId = procedureId_example;  // String |  (default to null)
            var updateProcedureRequest = new UpdateProcedureRequest(); // UpdateProcedureRequest |  (optional) 

            try {
                'String' result = apiInstance.updateProcedure(graphId, procedureId, updateProcedureRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceProcedureManagementApi.updateProcedure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceProcedureManagementApi();
$graphId = graphId_example; // String | 
$procedureId = procedureId_example; // String | 
$updateProcedureRequest = ; // UpdateProcedureRequest | 

try {
    $result = $api_instance->updateProcedure($graphId, $procedureId, $updateProcedureRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceProcedureManagementApi->updateProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceProcedureManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceProcedureManagementApi->new();
my $graphId = graphId_example; # String | 
my $procedureId = procedureId_example; # String | 
my $updateProcedureRequest = WWW::OPenAPIClient::Object::UpdateProcedureRequest->new(); # UpdateProcedureRequest | 

eval {
    my $result = $api_instance->updateProcedure(graphId => $graphId, procedureId => $procedureId, updateProcedureRequest => $updateProcedureRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceProcedureManagementApi->updateProcedure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceProcedureManagementApi()
graphId = graphId_example # String |  (default to null)
procedureId = procedureId_example # String |  (default to null)
updateProcedureRequest =  # UpdateProcedureRequest |  (optional)

try:
    api_response = api_instance.update_procedure(graphId, procedureId, updateProcedureRequest=updateProcedureRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceProcedureManagementApi->updateProcedure: %s\n" % e)

extern crate AdminServiceProcedureManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let procedureId = procedureId_example; // String
    let updateProcedureRequest = ; // UpdateProcedureRequest

    let mut context = AdminServiceProcedureManagementApi::Context::default();
    let result = client.updateProcedure(graphId, procedureId, updateProcedureRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
procedure_id*	String Required

Body parameters

Name	Description
updateProcedureRequest

Responses

Schema

Schema

Schema

Schema

AdminServiceServiceManagement

checkServiceReady

Check if the service is ready

/v1/service/ready

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/service/ready"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            'String' result = apiInstance.checkServiceReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#checkServiceReady");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.checkServiceReady();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkServiceReady: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            'String' result = apiInstance.checkServiceReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#checkServiceReady");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];

[apiInstance checkServiceReadyWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.checkServiceReady(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class checkServiceReadyExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();

            try {
                'String' result = apiInstance.checkServiceReady();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.checkServiceReady: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();

try {
    $result = $api_instance->checkServiceReady();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceManagementApi->checkServiceReady: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();

eval {
    my $result = $api_instance->checkServiceReady();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceManagementApi->checkServiceReady: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()

try:
    api_response = api_instance.check_service_ready()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->checkServiceReady: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.checkServiceReady(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

getServiceStatus

Get service status

/v1/service/status

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/service/status"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            ServiceStatus result = apiInstance.getServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#getServiceStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getServiceStatus();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getServiceStatus: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            ServiceStatus result = apiInstance.getServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#getServiceStatus");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];

[apiInstance getServiceStatusWithCompletionHandler: 
              ^(ServiceStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getServiceStatus(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getServiceStatusExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();

            try {
                ServiceStatus result = apiInstance.getServiceStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.getServiceStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();

try {
    $result = $api_instance->getServiceStatus();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceManagementApi->getServiceStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();

eval {
    my $result = $api_instance->getServiceStatus();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceManagementApi->getServiceStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()

try:
    api_response = api_instance.get_service_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->getServiceStatus: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.getServiceStatus(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

restartService

Start current service

/v1/service/restart

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost/v1/service/restart"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            'String' result = apiInstance.restartService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#restartService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.restartService();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->restartService: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();

        try {
            'String' result = apiInstance.restartService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#restartService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];

[apiInstance restartServiceWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartService(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class restartServiceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();

            try {
                'String' result = apiInstance.restartService();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.restartService: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();

try {
    $result = $api_instance->restartService();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceManagementApi->restartService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();

eval {
    my $result = $api_instance->restartService();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceManagementApi->restartService: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()

try:
    api_response = api_instance.restart_service()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->restartService: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.restartService(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

startService

Start service on a specified graph

/v1/service/start

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/service/start" \
 -d '{
  "graph_id" : "graph_id"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

        try {
            'String' result = apiInstance.startService(startServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#startService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StartServiceRequest startServiceRequest = new StartServiceRequest(); // StartServiceRequest | 

try {
    final result = await api_instance.startService(startServiceRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startService: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

        try {
            'String' result = apiInstance.startService(startServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#startService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];
StartServiceRequest *startServiceRequest = ; //  (optional)

[apiInstance startServiceWith:startServiceRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var opts = {
  'startServiceRequest':  // {StartServiceRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startService(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class startServiceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();
            var startServiceRequest = new StartServiceRequest(); // StartServiceRequest |  (optional) 

            try {
                'String' result = apiInstance.startService(startServiceRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.startService: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();
$startServiceRequest = ; // StartServiceRequest | 

try {
    $result = $api_instance->startService($startServiceRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceManagementApi->startService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();
my $startServiceRequest = WWW::OPenAPIClient::Object::StartServiceRequest->new(); # StartServiceRequest | 

eval {
    my $result = $api_instance->startService(startServiceRequest => $startServiceRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceManagementApi->startService: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()
startServiceRequest =  # StartServiceRequest |  (optional)

try:
    api_response = api_instance.start_service(startServiceRequest=startServiceRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->startService: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {
    let startServiceRequest = ; // StartServiceRequest

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.startService(startServiceRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
startServiceRequest	Start service on a specified graph

Responses

Schema

Schema

stopService

Stop current service

/v1/service/stop

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/service/stop" \
 -d '{
  "graph_id" : "graph_id"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceManagementApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StopServiceRequest stopServiceRequest = ; // StopServiceRequest | 

        try {
            'String' result = apiInstance.stopService(stopServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#stopService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StopServiceRequest stopServiceRequest = new StopServiceRequest(); // StopServiceRequest | 

try {
    final result = await api_instance.stopService(stopServiceRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->stopService: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceManagementApi;

public class AdminServiceServiceManagementApiExample {
    public static void main(String[] args) {
        AdminServiceServiceManagementApi apiInstance = new AdminServiceServiceManagementApi();
        StopServiceRequest stopServiceRequest = ; // StopServiceRequest | 

        try {
            'String' result = apiInstance.stopService(stopServiceRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceManagementApi#stopService");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceManagementApi *apiInstance = [[AdminServiceServiceManagementApi alloc] init];
StopServiceRequest *stopServiceRequest = ; //  (optional)

[apiInstance stopServiceWith:stopServiceRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceManagementApi()
var opts = {
  'stopServiceRequest':  // {StopServiceRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopService(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class stopServiceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceManagementApi();
            var stopServiceRequest = new StopServiceRequest(); // StopServiceRequest |  (optional) 

            try {
                'String' result = apiInstance.stopService(stopServiceRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceManagementApi.stopService: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceManagementApi();
$stopServiceRequest = ; // StopServiceRequest | 

try {
    $result = $api_instance->stopService($stopServiceRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceManagementApi->stopService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceManagementApi->new();
my $stopServiceRequest = WWW::OPenAPIClient::Object::StopServiceRequest->new(); # StopServiceRequest | 

eval {
    my $result = $api_instance->stopService(stopServiceRequest => $stopServiceRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceManagementApi->stopService: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceManagementApi()
stopServiceRequest =  # StopServiceRequest |  (optional)

try:
    api_response = api_instance.stop_service(stopServiceRequest=stopServiceRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceManagementApi->stopService: %s\n" % e)

extern crate AdminServiceServiceManagementApi;

pub fn main() {
    let stopServiceRequest = ; // StopServiceRequest

    let mut context = AdminServiceServiceManagementApi::Context::default();
    let result = client.stopService(stopServiceRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
stopServiceRequest	Stop service on a specified graph

Responses

Schema

AdminServiceServiceRegistry

getServiceRegistryInfo

Get a service registry by graph_id and service_name

/v1/service/registry/{graph_id}/{service_name}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/service/registry/{graph_id}/{service_name}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceRegistryApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceRegistryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceRegistryApi apiInstance = new AdminServiceServiceRegistryApi();
        String graphId = graphId_example; // String | 
        String serviceName = serviceName_example; // String | 

        try {
            GraphServiceRegistryRecord result = apiInstance.getServiceRegistryInfo(graphId, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceRegistryApi#getServiceRegistryInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String serviceName = new String(); // String | 

try {
    final result = await api_instance.getServiceRegistryInfo(graphId, serviceName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getServiceRegistryInfo: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceRegistryApi;

public class AdminServiceServiceRegistryApiExample {
    public static void main(String[] args) {
        AdminServiceServiceRegistryApi apiInstance = new AdminServiceServiceRegistryApi();
        String graphId = graphId_example; // String | 
        String serviceName = serviceName_example; // String | 

        try {
            GraphServiceRegistryRecord result = apiInstance.getServiceRegistryInfo(graphId, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceRegistryApi#getServiceRegistryInfo");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceRegistryApi *apiInstance = [[AdminServiceServiceRegistryApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *serviceName = serviceName_example; //  (default to null)

[apiInstance getServiceRegistryInfoWith:graphId
    serviceName:serviceName
              completionHandler: ^(GraphServiceRegistryRecord output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceRegistryApi()
var graphId = graphId_example; // {String} 
var serviceName = serviceName_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getServiceRegistryInfo(graphId, serviceName, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getServiceRegistryInfoExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceRegistryApi();
            var graphId = graphId_example;  // String |  (default to null)
            var serviceName = serviceName_example;  // String |  (default to null)

            try {
                GraphServiceRegistryRecord result = apiInstance.getServiceRegistryInfo(graphId, serviceName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceRegistryApi.getServiceRegistryInfo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceRegistryApi();
$graphId = graphId_example; // String | 
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getServiceRegistryInfo($graphId, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceRegistryApi->getServiceRegistryInfo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceRegistryApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceRegistryApi->new();
my $graphId = graphId_example; # String | 
my $serviceName = serviceName_example; # String | 

eval {
    my $result = $api_instance->getServiceRegistryInfo(graphId => $graphId, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceRegistryApi->getServiceRegistryInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceRegistryApi()
graphId = graphId_example # String |  (default to null)
serviceName = serviceName_example # String |  (default to null)

try:
    api_response = api_instance.get_service_registry_info(graphId, serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceRegistryApi->getServiceRegistryInfo: %s\n" % e)

extern crate AdminServiceServiceRegistryApi;

pub fn main() {
    let graphId = graphId_example; // String
    let serviceName = serviceName_example; // String

    let mut context = AdminServiceServiceRegistryApi::Context::default();
    let result = client.getServiceRegistryInfo(graphId, serviceName, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
service_name*	String Required

Responses

Schema

Schema

Schema

listServiceRegistryInfo

List all services registry

/v1/service/registry

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/service/registry"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdminServiceServiceRegistryApi;

import java.io.File;
import java.util.*;

public class AdminServiceServiceRegistryApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminServiceServiceRegistryApi apiInstance = new AdminServiceServiceRegistryApi();

        try {
            array[GraphServiceRegistryRecord] result = apiInstance.listServiceRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceRegistryApi#listServiceRegistryInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listServiceRegistryInfo();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listServiceRegistryInfo: $e\n');
}

import org.openapitools.client.api.AdminServiceServiceRegistryApi;

public class AdminServiceServiceRegistryApiExample {
    public static void main(String[] args) {
        AdminServiceServiceRegistryApi apiInstance = new AdminServiceServiceRegistryApi();

        try {
            array[GraphServiceRegistryRecord] result = apiInstance.listServiceRegistryInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminServiceServiceRegistryApi#listServiceRegistryInfo");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdminServiceServiceRegistryApi *apiInstance = [[AdminServiceServiceRegistryApi alloc] init];

[apiInstance listServiceRegistryInfoWithCompletionHandler: 
              ^(array[GraphServiceRegistryRecord] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.AdminServiceServiceRegistryApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listServiceRegistryInfo(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class listServiceRegistryInfoExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AdminServiceServiceRegistryApi();

            try {
                array[GraphServiceRegistryRecord] result = apiInstance.listServiceRegistryInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminServiceServiceRegistryApi.listServiceRegistryInfo: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminServiceServiceRegistryApi();

try {
    $result = $api_instance->listServiceRegistryInfo();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdminServiceServiceRegistryApi->listServiceRegistryInfo: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminServiceServiceRegistryApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminServiceServiceRegistryApi->new();

eval {
    my $result = $api_instance->listServiceRegistryInfo();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminServiceServiceRegistryApi->listServiceRegistryInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.AdminServiceServiceRegistryApi()

try:
    api_response = api_instance.list_service_registry_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminServiceServiceRegistryApi->listServiceRegistryInfo: %s\n" % e)

extern crate AdminServiceServiceRegistryApi;

pub fn main() {

    let mut context = AdminServiceServiceRegistryApi::Context::default();
    let result = client.listServiceRegistryInfo(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

GraphServiceEdgeManagement

addEdge

Add edge to the graph

Add the edge to graph.

/v1/graph/{graph_id}/edge

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/edge" \
 -d '{
  "src_label" : "person",
  "dst_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "dst_label" : "software",
  "src_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "edge_label" : "created",
  "properties" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceEdgeManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.addEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#addEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final array[EdgeRequest] edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

try {
    final result = await api_instance.addEdge(graphId, edgeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.addEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#addEdge");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
array[EdgeRequest] *edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // 

// Add edge to the graph
[apiInstance addEdgeWith:graphId
    edgeRequest:edgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // {array[EdgeRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addEdge(graphId, edgeRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addEdgeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

            try {
                // Add edge to the graph
                'String' result = apiInstance.addEdge(graphId, edgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.addEdge: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

try {
    $result = $api_instance->addEdge($graphId, $edgeRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->addEdge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceEdgeManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeRequest = [WWW::OPenAPIClient::Object::array[EdgeRequest]->new()]; # array[EdgeRequest] | 

eval {
    my $result = $api_instance->addEdge(graphId => $graphId, edgeRequest => $edgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->addEdge: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}] # array[EdgeRequest] | 

try:
    # Add edge to the graph
    api_response = api_instance.add_edge(graphId, edgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->addEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest]

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.addEdge(graphId, edgeRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
edgeRequest *

Responses

Schema

Schema

Schema

Schema

deleteEdge

Remove edge from the graph

Remove the edge from current graph.

/v1/graph/{graph_id}/edge

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/edge" \
 -d '{
  "src_label" : "person",
  "dst_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "dst_label" : "software",
  "src_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "edge_label" : "created",
  "properties" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceEdgeManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[DeleteEdgeRequest] deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

        try {
            'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#deleteEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final array[DeleteEdgeRequest] deleteEdgeRequest = new array[DeleteEdgeRequest](); // array[DeleteEdgeRequest] | 

try {
    final result = await api_instance.deleteEdge(graphId, deleteEdgeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[DeleteEdgeRequest] deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

        try {
            'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#deleteEdge");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
array[DeleteEdgeRequest] *deleteEdgeRequest = ; // 

// Remove edge from the graph
[apiInstance deleteEdgeWith:graphId
    deleteEdgeRequest:deleteEdgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var deleteEdgeRequest = ; // {array[DeleteEdgeRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEdge(graphId, deleteEdgeRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteEdgeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var deleteEdgeRequest = new array[DeleteEdgeRequest](); // array[DeleteEdgeRequest] | 

            try {
                // Remove edge from the graph
                'String' result = apiInstance.deleteEdge(graphId, deleteEdgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.deleteEdge: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$deleteEdgeRequest = ; // array[DeleteEdgeRequest] | 

try {
    $result = $api_instance->deleteEdge($graphId, $deleteEdgeRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->deleteEdge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceEdgeManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $deleteEdgeRequest = [WWW::OPenAPIClient::Object::array[DeleteEdgeRequest]->new()]; # array[DeleteEdgeRequest] | 

eval {
    my $result = $api_instance->deleteEdge(graphId => $graphId, deleteEdgeRequest => $deleteEdgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->deleteEdge: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
deleteEdgeRequest =  # array[DeleteEdgeRequest] | 

try:
    # Remove edge from the graph
    api_response = api_instance.delete_edge(graphId, deleteEdgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->deleteEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let deleteEdgeRequest = ; // array[DeleteEdgeRequest]

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.deleteEdge(graphId, deleteEdgeRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
deleteEdgeRequest *	The label and primary key values of the src and dst vertices, and the edge label.

Responses

Schema

Schema

Schema

Schema

getEdge

Get the edge's properties with src and dst vertex primary keys.

Get the properties for the specified vertex.

/v1/graph/{graph_id}/edge

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/edge?edge_label=created&src_label=person&src_primary_key_value=1&dst_label=software&dst_primary_key_value=3"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceEdgeManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String edgeLabel = created; // String | The label name of querying edge.
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

        try {
            EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#getEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String edgeLabel = new String(); // String | The label name of querying edge.
final String srcLabel = new String(); // String | The label name of src vertex.
final oas_any_type_not_mapped srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex.
final String dstLabel = new String(); // String | The label name of dst vertex.
final oas_any_type_not_mapped dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of dst vertex's primary key

try {
    final result = await api_instance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        String edgeLabel = created; // String | The label name of querying edge.
        String srcLabel = person; // String | The label name of src vertex.
        oas_any_type_not_mapped srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
        String dstLabel = software; // String | The label name of dst vertex.
        oas_any_type_not_mapped dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

        try {
            EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#getEdge");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *edgeLabel = created; // The label name of querying edge. (default to null)
String *srcLabel = person; // The label name of src vertex. (default to null)
oas_any_type_not_mapped *srcPrimaryKeyValue = 1; // The primary key value of src vertex. (default to null)
String *dstLabel = software; // The label name of dst vertex. (default to null)
oas_any_type_not_mapped *dstPrimaryKeyValue = 3; // The value of dst vertex's primary key (default to null)

// Get the edge's properties with src and dst vertex primary keys.
[apiInstance getEdgeWith:graphId
    edgeLabel:edgeLabel
    srcLabel:srcLabel
    srcPrimaryKeyValue:srcPrimaryKeyValue
    dstLabel:dstLabel
    dstPrimaryKeyValue:dstPrimaryKeyValue
              completionHandler: ^(EdgeData output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var edgeLabel = created; // {String} The label name of querying edge.
var srcLabel = person; // {String} The label name of src vertex.
var srcPrimaryKeyValue = 1; // {oas_any_type_not_mapped} The primary key value of src vertex.
var dstLabel = software; // {String} The label name of dst vertex.
var dstPrimaryKeyValue = 3; // {oas_any_type_not_mapped} The value of dst vertex's primary key

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getEdgeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeLabel = created;  // String | The label name of querying edge. (default to null)
            var srcLabel = person;  // String | The label name of src vertex. (default to null)
            var srcPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
            var dstLabel = software;  // String | The label name of dst vertex. (default to null)
            var dstPrimaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The value of dst vertex's primary key (default to null)

            try {
                // Get the edge's properties with src and dst vertex primary keys.
                EdgeData result = apiInstance.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.getEdge: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeLabel = created; // String | The label name of querying edge.
$srcLabel = person; // String | The label name of src vertex.
$srcPrimaryKeyValue = 1; // oas_any_type_not_mapped | The primary key value of src vertex.
$dstLabel = software; // String | The label name of dst vertex.
$dstPrimaryKeyValue = 3; // oas_any_type_not_mapped | The value of dst vertex's primary key

try {
    $result = $api_instance->getEdge($graphId, $edgeLabel, $srcLabel, $srcPrimaryKeyValue, $dstLabel, $dstPrimaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->getEdge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceEdgeManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeLabel = created; # String | The label name of querying edge.
my $srcLabel = person; # String | The label name of src vertex.
my $srcPrimaryKeyValue = 1; # oas_any_type_not_mapped | The primary key value of src vertex.
my $dstLabel = software; # String | The label name of dst vertex.
my $dstPrimaryKeyValue = 3; # oas_any_type_not_mapped | The value of dst vertex's primary key

eval {
    my $result = $api_instance->getEdge(graphId => $graphId, edgeLabel => $edgeLabel, srcLabel => $srcLabel, srcPrimaryKeyValue => $srcPrimaryKeyValue, dstLabel => $dstLabel, dstPrimaryKeyValue => $dstPrimaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->getEdge: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeLabel = created # String | The label name of querying edge. (default to null)
srcLabel = person # String | The label name of src vertex. (default to null)
srcPrimaryKeyValue = 1 # oas_any_type_not_mapped | The primary key value of src vertex. (default to null)
dstLabel = software # String | The label name of dst vertex. (default to null)
dstPrimaryKeyValue = 3 # oas_any_type_not_mapped | The value of dst vertex's primary key (default to null)

try:
    # Get the edge's properties with src and dst vertex primary keys.
    api_response = api_instance.get_edge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->getEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeLabel = created; // String
    let srcLabel = person; // String
    let srcPrimaryKeyValue = 1; // oas_any_type_not_mapped
    let dstLabel = software; // String
    let dstPrimaryKeyValue = 3; // oas_any_type_not_mapped

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.getEdge(graphId, edgeLabel, srcLabel, srcPrimaryKeyValue, dstLabel, dstPrimaryKeyValue, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Query parameters

Name	Description
edge_label*	String The label name of querying edge. Required
src_label*	String The label name of src vertex. Required
src_primary_key_value*	oas_any_type_not_mapped The primary key value of src vertex. Required
dst_label*	String The label name of dst vertex. Required
dst_primary_key_value*	oas_any_type_not_mapped The value of dst vertex's primary key Required

Responses

Schema

Schema

Schema

Schema

updateEdge

Update edge's property

Update the edge on the running graph.

/v1/graph/{graph_id}/edge

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/edge" \
 -d '{
  "src_label" : "person",
  "dst_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "dst_label" : "software",
  "src_primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "edge_label" : "created",
  "properties" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceEdgeManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.updateEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#updateEdge");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final array[EdgeRequest] edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

try {
    final result = await api_instance.updateEdge(graphId, edgeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateEdge: $e\n');
}

import org.openapitools.client.api.GraphServiceEdgeManagementApi;

public class GraphServiceEdgeManagementApiExample {
    public static void main(String[] args) {
        GraphServiceEdgeManagementApi apiInstance = new GraphServiceEdgeManagementApi();
        String graphId = graphId_example; // String | 
        array[EdgeRequest] edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

        try {
            'String' result = apiInstance.updateEdge(graphId, edgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceEdgeManagementApi#updateEdge");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceEdgeManagementApi *apiInstance = [[GraphServiceEdgeManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
array[EdgeRequest] *edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // 

// Update edge's property
[apiInstance updateEdgeWith:graphId
    edgeRequest:edgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceEdgeManagementApi()
var graphId = graphId_example; // {String} 
var edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // {array[EdgeRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateEdge(graphId, edgeRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateEdgeExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceEdgeManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var edgeRequest = new array[EdgeRequest](); // array[EdgeRequest] | 

            try {
                // Update edge's property
                'String' result = apiInstance.updateEdge(graphId, edgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceEdgeManagementApi.updateEdge: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceEdgeManagementApi();
$graphId = graphId_example; // String | 
$edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest] | 

try {
    $result = $api_instance->updateEdge($graphId, $edgeRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceEdgeManagementApi->updateEdge: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceEdgeManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceEdgeManagementApi->new();
my $graphId = graphId_example; # String | 
my $edgeRequest = [WWW::OPenAPIClient::Object::array[EdgeRequest]->new()]; # array[EdgeRequest] | 

eval {
    my $result = $api_instance->updateEdge(graphId => $graphId, edgeRequest => $edgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceEdgeManagementApi->updateEdge: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceEdgeManagementApi()
graphId = graphId_example # String |  (default to null)
edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}] # array[EdgeRequest] | 

try:
    # Update edge's property
    api_response = api_instance.update_edge(graphId, edgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceEdgeManagementApi->updateEdge: %s\n" % e)

extern crate GraphServiceEdgeManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let edgeRequest = [{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]; // array[EdgeRequest]

    let mut context = GraphServiceEdgeManagementApi::Context::default();
    let result = client.updateEdge(graphId, edgeRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
edgeRequest *

Responses

Schema

Schema

Schema

Schema

GraphServiceVertexManagement

addVertex

Add vertex (and edge) to the graph

Add the provided vertex (and edge) to the specified graph.

/v1/graph/{graph_id}/vertex

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/vertex" \
 -d '{
  "vertex_request" : [ {
    "primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "label" : "person",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  }, {
    "primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "label" : "person",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  } ],
  "edge_request" : [ {
    "src_label" : "person",
    "dst_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "dst_label" : "software",
    "src_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "edge_label" : "created",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  }, {
    "src_label" : "person",
    "dst_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "dst_label" : "software",
    "src_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "edge_label" : "created",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceVertexManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#addVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final VertexEdgeRequest vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

try {
    final result = await api_instance.addVertex(graphId, vertexEdgeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addVertex: $e\n');
}

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#addVertex");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
VertexEdgeRequest *vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // 

// Add vertex (and edge) to the graph
[apiInstance addVertexWith:graphId
    vertexEdgeRequest:vertexEdgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // {VertexEdgeRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addVertex(graphId, vertexEdgeRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addVertexExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

            try {
                // Add vertex (and edge) to the graph
                'String' result = apiInstance.addVertex(graphId, vertexEdgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.addVertex: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest | 

try {
    $result = $api_instance->addVertex($graphId, $vertexEdgeRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->addVertex: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceVertexManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $vertexEdgeRequest = WWW::OPenAPIClient::Object::VertexEdgeRequest->new(); # VertexEdgeRequest | 

eval {
    my $result = $api_instance->addVertex(graphId => $graphId, vertexEdgeRequest => $vertexEdgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->addVertex: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]} # VertexEdgeRequest | 

try:
    # Add vertex (and edge) to the graph
    api_response = api_instance.add_vertex(graphId, vertexEdgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->addVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let vertexEdgeRequest = {"vertex_request":[{"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}],"edge_request":[{"src_label":"person","dst_label":"software","edge_label":"created","src_primary_key_values":[{"name":"id","value":1}],"dst_primary_key_values":[{"name":"id","value":3}],"properties":[{"name":"weight","value":0.2}]}]}; // VertexEdgeRequest

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.addVertex(graphId, vertexEdgeRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
vertexEdgeRequest *

Responses

Schema

Schema

Schema

Schema

Schema

deleteVertex

Remove vertex from the graph

Remove the vertex from the specified graph.

/v1/graph/{graph_id}/vertex

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/vertex" \
 -d '{
  "primary_key_values" : [ {
    "name" : "id",
    "value" : ""
  }, {
    "name" : "id",
    "value" : ""
  } ],
  "label" : "person"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceVertexManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        array[DeleteVertexRequest] deleteVertexRequest = ; // array[DeleteVertexRequest] | 

        try {
            'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#deleteVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final array[DeleteVertexRequest] deleteVertexRequest = new array[DeleteVertexRequest](); // array[DeleteVertexRequest] | 

try {
    final result = await api_instance.deleteVertex(graphId, deleteVertexRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteVertex: $e\n');
}

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        array[DeleteVertexRequest] deleteVertexRequest = ; // array[DeleteVertexRequest] | 

        try {
            'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#deleteVertex");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
array[DeleteVertexRequest] *deleteVertexRequest = ; // 

// Remove vertex from the graph
[apiInstance deleteVertexWith:graphId
    deleteVertexRequest:deleteVertexRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var deleteVertexRequest = ; // {array[DeleteVertexRequest]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteVertex(graphId, deleteVertexRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteVertexExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var deleteVertexRequest = new array[DeleteVertexRequest](); // array[DeleteVertexRequest] | 

            try {
                // Remove vertex from the graph
                'String' result = apiInstance.deleteVertex(graphId, deleteVertexRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.deleteVertex: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$deleteVertexRequest = ; // array[DeleteVertexRequest] | 

try {
    $result = $api_instance->deleteVertex($graphId, $deleteVertexRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->deleteVertex: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceVertexManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $deleteVertexRequest = [WWW::OPenAPIClient::Object::array[DeleteVertexRequest]->new()]; # array[DeleteVertexRequest] | 

eval {
    my $result = $api_instance->deleteVertex(graphId => $graphId, deleteVertexRequest => $deleteVertexRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->deleteVertex: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
deleteVertexRequest =  # array[DeleteVertexRequest] | 

try:
    # Remove vertex from the graph
    api_response = api_instance.delete_vertex(graphId, deleteVertexRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->deleteVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let deleteVertexRequest = ; // array[DeleteVertexRequest]

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.deleteVertex(graphId, deleteVertexRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
deleteVertexRequest *	The label and primary key values of the vertex to be deleted.

Responses

Schema

Schema

Schema

Schema

getVertex

Get the vertex's properties with vertex primary key.

Get the properties for the specified vertex. example: ```http GET /endpoint?param1=value1&param2=value2 HTTP/1.1 Host: example.com ```

/v1/graph/{graph_id}/vertex

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v1/graph/{graph_id}/vertex?label=label_example&primary_key_value="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceVertexManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | The id of the graph
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

        try {
            VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#getVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | The id of the graph
final String label = new String(); // String | The label name of querying vertex.
final oas_any_type_not_mapped primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of querying vertex.

try {
    final result = await api_instance.getVertex(graphId, label, primaryKeyValue);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getVertex: $e\n');
}

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | The id of the graph
        String label = label_example; // String | The label name of querying vertex.
        oas_any_type_not_mapped primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

        try {
            VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#getVertex");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; // The id of the graph (default to null)
String *label = label_example; // The label name of querying vertex. (default to null)
oas_any_type_not_mapped *primaryKeyValue = ; // The primary key value of querying vertex. (default to null)

// Get the vertex's properties with vertex primary key.
[apiInstance getVertexWith:graphId
    label:label
    primaryKeyValue:primaryKeyValue
              completionHandler: ^(VertexData output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} The id of the graph
var label = label_example; // {String} The label name of querying vertex.
var primaryKeyValue = ; // {oas_any_type_not_mapped} The primary key value of querying vertex.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getVertex(graphId, label, primaryKeyValue, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getVertexExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String | The id of the graph (default to null)
            var label = label_example;  // String | The label name of querying vertex. (default to null)
            var primaryKeyValue = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | The primary key value of querying vertex. (default to null)

            try {
                // Get the vertex's properties with vertex primary key.
                VertexData result = apiInstance.getVertex(graphId, label, primaryKeyValue);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.getVertex: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | The id of the graph
$label = label_example; // String | The label name of querying vertex.
$primaryKeyValue = ; // oas_any_type_not_mapped | The primary key value of querying vertex.

try {
    $result = $api_instance->getVertex($graphId, $label, $primaryKeyValue);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->getVertex: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceVertexManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | The id of the graph
my $label = label_example; # String | The label name of querying vertex.
my $primaryKeyValue = ; # oas_any_type_not_mapped | The primary key value of querying vertex.

eval {
    my $result = $api_instance->getVertex(graphId => $graphId, label => $label, primaryKeyValue => $primaryKeyValue);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->getVertex: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String | The id of the graph (default to null)
label = label_example # String | The label name of querying vertex. (default to null)
primaryKeyValue =  # oas_any_type_not_mapped | The primary key value of querying vertex. (default to null)

try:
    # Get the vertex's properties with vertex primary key.
    api_response = api_instance.get_vertex(graphId, label, primaryKeyValue)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->getVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let label = label_example; // String
    let primaryKeyValue = ; // oas_any_type_not_mapped

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.getVertex(graphId, label, primaryKeyValue, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String The id of the graph Required

Query parameters

Name	Description
label*	String The label name of querying vertex. Required
primary_key_value*	oas_any_type_not_mapped The primary key value of querying vertex. Required

Responses

Schema

updateVertex

Update vertex's property

Update the vertex with the provided properties to the specified graph.

/v1/graph/{graph_id}/vertex

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v1/graph/{graph_id}/vertex" \
 -d '{
  "vertex_request" : [ {
    "primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "label" : "person",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  }, {
    "primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "label" : "person",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  } ],
  "edge_request" : [ {
    "src_label" : "person",
    "dst_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "dst_label" : "software",
    "src_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "edge_label" : "created",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  }, {
    "src_label" : "person",
    "dst_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "dst_label" : "software",
    "src_primary_key_values" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ],
    "edge_label" : "created",
    "properties" : [ {
      "name" : "id",
      "value" : ""
    }, {
      "name" : "id",
      "value" : ""
    } ]
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphServiceVertexManagementApi;

import java.io.File;
import java.util.*;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#updateVertex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final VertexEdgeRequest vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

try {
    final result = await api_instance.updateVertex(graphId, vertexEdgeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateVertex: $e\n');
}

import org.openapitools.client.api.GraphServiceVertexManagementApi;

public class GraphServiceVertexManagementApiExample {
    public static void main(String[] args) {
        GraphServiceVertexManagementApi apiInstance = new GraphServiceVertexManagementApi();
        String graphId = graphId_example; // String | 
        VertexEdgeRequest vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

        try {
            'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphServiceVertexManagementApi#updateVertex");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphServiceVertexManagementApi *apiInstance = [[GraphServiceVertexManagementApi alloc] init];
String *graphId = graphId_example; //  (default to null)
VertexEdgeRequest *vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // 

// Update vertex's property
[apiInstance updateVertexWith:graphId
    vertexEdgeRequest:vertexEdgeRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.GraphServiceVertexManagementApi()
var graphId = graphId_example; // {String} 
var vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // {VertexEdgeRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateVertex(graphId, vertexEdgeRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateVertexExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GraphServiceVertexManagementApi();
            var graphId = graphId_example;  // String |  (default to null)
            var vertexEdgeRequest = new VertexEdgeRequest(); // VertexEdgeRequest | 

            try {
                // Update vertex's property
                'String' result = apiInstance.updateVertex(graphId, vertexEdgeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphServiceVertexManagementApi.updateVertex: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphServiceVertexManagementApi();
$graphId = graphId_example; // String | 
$vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest | 

try {
    $result = $api_instance->updateVertex($graphId, $vertexEdgeRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphServiceVertexManagementApi->updateVertex: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GraphServiceVertexManagementApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphServiceVertexManagementApi->new();
my $graphId = graphId_example; # String | 
my $vertexEdgeRequest = WWW::OPenAPIClient::Object::VertexEdgeRequest->new(); # VertexEdgeRequest | 

eval {
    my $result = $api_instance->updateVertex(graphId => $graphId, vertexEdgeRequest => $vertexEdgeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphServiceVertexManagementApi->updateVertex: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GraphServiceVertexManagementApi()
graphId = graphId_example # String |  (default to null)
vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}} # VertexEdgeRequest | 

try:
    # Update vertex's property
    api_response = api_instance.update_vertex(graphId, vertexEdgeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphServiceVertexManagementApi->updateVertex: %s\n" % e)

extern crate GraphServiceVertexManagementApi;

pub fn main() {
    let graphId = graphId_example; // String
    let vertexEdgeRequest = {"label":"person","primary_key_value":2,"properties":{"age":24,"name":"Cindy"}}; // VertexEdgeRequest

    let mut context = GraphServiceVertexManagementApi::Context::default();
    let result = client.updateVertex(graphId, vertexEdgeRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
vertexEdgeRequest *

Responses

Schema

Schema

Schema

Schema

QueryService

callProc

run queries on graph

After the procedure is created, user can use this API to run the procedure.

/v1/graph/{graph_id}/query

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: text/plain" \
 "http://localhost/v1/graph/{graph_id}/query" \
 -d 'Custom MIME type example not yet supported: text/plain'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.QueryServiceApi;

import java.io.File;
import java.util.*;

public class QueryServiceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProc");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final byte[] body = new byte[](); // byte[] | 

try {
    final result = await api_instance.callProc(graphId, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->callProc: $e\n');
}

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProc");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// run queries on graph
[apiInstance callProcWith:graphId
    body:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var graphId = graphId_example; // {String} 
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.callProc(graphId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class callProcExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // run queries on graph
                byte[] result = apiInstance.callProc(graphId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.callProc: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$graphId = graphId_example; // String | 
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

try {
    $result = $api_instance->callProc($graphId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling QueryServiceApi->callProc: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::QueryServiceApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $graphId = graphId_example; # String | 
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

eval {
    my $result = $api_instance->callProc(graphId => $graphId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling QueryServiceApi->callProc: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
graphId = graphId_example # String |  (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # run queries on graph
    api_response = api_instance.call_proc(graphId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->callProc: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.callProc(graphId, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
body

Responses

Schema

Schema

callProcCurrent

run queries on the running graph

Submit a query to the running graph.

/v1/graph/current/query

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: text/plain" \
 "http://localhost/v1/graph/current/query" \
 -d 'Custom MIME type example not yet supported: text/plain'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.QueryServiceApi;

import java.io.File;
import java.util.*;

public class QueryServiceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProcCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProcCurrent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final byte[] body = new byte[](); // byte[] | 

try {
    final result = await api_instance.callProcCurrent(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->callProcCurrent: $e\n');
}

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.callProcCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#callProcCurrent");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// run queries on the running graph
[apiInstance callProcCurrentWith:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.callProcCurrent(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class callProcCurrentExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // run queries on the running graph
                byte[] result = apiInstance.callProcCurrent(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.callProcCurrent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

try {
    $result = $api_instance->callProcCurrent($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling QueryServiceApi->callProcCurrent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::QueryServiceApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

eval {
    my $result = $api_instance->callProcCurrent(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling QueryServiceApi->callProcCurrent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # run queries on the running graph
    api_response = api_instance.call_proc_current(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->callProcCurrent: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.callProcCurrent(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body

Responses

Schema

Schema

runAdhoc

Submit adhoc query to the Interactive Query Service.

Submit a adhoc query to the running graph. The adhoc query should be represented by the physical plan: https://github.com/alibaba/GraphScope/blob/main/interactive_engine/executor/ir/proto/physical.proto

/v1/graph/{graph_id}/adhoc_query

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: text/plain" \
 "http://localhost/v1/graph/{graph_id}/adhoc_query" \
 -d 'Custom MIME type example not yet supported: text/plain'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.QueryServiceApi;

import java.io.File;
import java.util.*;

public class QueryServiceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhoc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhoc");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final byte[] body = new byte[](); // byte[] | 

try {
    final result = await api_instance.runAdhoc(graphId, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->runAdhoc: $e\n');
}

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        String graphId = graphId_example; // String | 
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhoc(graphId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhoc");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// Submit adhoc query to the Interactive Query Service.
[apiInstance runAdhocWith:graphId
    body:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var graphId = graphId_example; // {String} 
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.runAdhoc(graphId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class runAdhocExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // Submit adhoc query to the Interactive Query Service.
                byte[] result = apiInstance.runAdhoc(graphId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.runAdhoc: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$graphId = graphId_example; // String | 
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

try {
    $result = $api_instance->runAdhoc($graphId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling QueryServiceApi->runAdhoc: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::QueryServiceApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $graphId = graphId_example; # String | 
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

eval {
    my $result = $api_instance->runAdhoc(graphId => $graphId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling QueryServiceApi->runAdhoc: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
graphId = graphId_example # String |  (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # Submit adhoc query to the Interactive Query Service.
    api_response = api_instance.run_adhoc(graphId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->runAdhoc: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.runAdhoc(graphId, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
body

Responses

Schema

Schema

runAdhocCurrent

Submit adhoc query to the Interactive Query Service.

/v1/graph/current/adhoc_query

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: text/plain" \
 "http://localhost/v1/graph/current/adhoc_query" \
 -d 'Custom MIME type example not yet supported: text/plain'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.QueryServiceApi;

import java.io.File;
import java.util.*;

public class QueryServiceApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhocCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhocCurrent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final byte[] body = new byte[](); // byte[] | 

try {
    final result = await api_instance.runAdhocCurrent(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->runAdhocCurrent: $e\n');
}

import org.openapitools.client.api.QueryServiceApi;

public class QueryServiceApiExample {
    public static void main(String[] args) {
        QueryServiceApi apiInstance = new QueryServiceApi();
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 

        try {
            byte[] result = apiInstance.runAdhocCurrent(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling QueryServiceApi#runAdhocCurrent");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
QueryServiceApi *apiInstance = [[QueryServiceApi alloc] init];
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// Submit adhoc query to the Interactive Query Service.
[apiInstance runAdhocCurrentWith:body
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.QueryServiceApi()
var opts = {
  'body': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.runAdhocCurrent(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class runAdhocCurrentExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new QueryServiceApi();
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] |  (optional) 

            try {
                // Submit adhoc query to the Interactive Query Service.
                byte[] result = apiInstance.runAdhocCurrent(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling QueryServiceApi.runAdhocCurrent: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\QueryServiceApi();
$body = BYTE_ARRAY_DATA_HERE; // byte[] | 

try {
    $result = $api_instance->runAdhocCurrent($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling QueryServiceApi->runAdhocCurrent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::QueryServiceApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::QueryServiceApi->new();
my $body = WWW::OPenAPIClient::Object::byte[]->new(); # byte[] | 

eval {
    my $result = $api_instance->runAdhocCurrent(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling QueryServiceApi->runAdhocCurrent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.QueryServiceApi()
body = BYTE_ARRAY_DATA_HERE # byte[] |  (optional)

try:
    # Submit adhoc query to the Interactive Query Service.
    api_response = api_instance.run_adhoc_current(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling QueryServiceApi->runAdhocCurrent: %s\n" % e)

extern crate QueryServiceApi;

pub fn main() {
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = QueryServiceApi::Context::default();
    let result = client.runAdhocCurrent(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body

Responses

Schema

Schema

Utils

uploadFile

/v1/file/upload

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "http://localhost/v1/file/upload"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UtilsApi;

import java.io.File;
import java.util.*;

public class UtilsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UtilsApi apiInstance = new UtilsApi();
        File filestorage = BINARY_DATA_HERE; // File | 

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final File filestorage = new File(); // File | 

try {
    final result = await api_instance.uploadFile(filestorage);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadFile: $e\n');
}

import org.openapitools.client.api.UtilsApi;

public class UtilsApiExample {
    public static void main(String[] args) {
        UtilsApi apiInstance = new UtilsApi();
        File filestorage = BINARY_DATA_HERE; // File | 

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UtilsApi *apiInstance = [[UtilsApi alloc] init];
File *filestorage = BINARY_DATA_HERE; //  (optional) (default to null)

[apiInstance uploadFileWith:filestorage
              completionHandler: ^(UploadFileResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeInteractiveApiV03 = require('graph_scope_interactive_api_v0_3');

// Create an instance of the API class
var api = new GraphScopeInteractiveApiV03.UtilsApi()
var opts = {
  'filestorage': BINARY_DATA_HERE // {File} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadFile(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class uploadFileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UtilsApi();
            var filestorage = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                UploadFileResponse result = apiInstance.uploadFile(filestorage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UtilsApi.uploadFile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UtilsApi();
$filestorage = BINARY_DATA_HERE; // File | 

try {
    $result = $api_instance->uploadFile($filestorage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UtilsApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UtilsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UtilsApi->new();
my $filestorage = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->uploadFile(filestorage => $filestorage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UtilsApi->uploadFile: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UtilsApi()
filestorage = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.upload_file(filestorage=filestorage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilsApi->uploadFile: %s\n" % e)

extern crate UtilsApi;

pub fn main() {
    let filestorage = BINARY_DATA_HERE; // File

    let mut context = UtilsApi::Context::default();
    let result = client.uploadFile(filestorage, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Form parameters

Name	Description
filestorage	File (binary)

Responses

Schema

Schema