Accessing the graph

Follow the installation instructions to install Boto3. If you are using a SageMaker AI hosted Jupyter notebook, Boto3 will be pre-installed, but you may need to update it.

Configure your Boto3 credentials by following the configuring credentials guide.

Create a file named queryExample.py.

In that file, paste the following code. It will set up a Neptune graph client, execute an openCypher query request, and print the result. Replace the graph identifier and query string as needed.

import boto3

// Set up the Neptune Graph client.
client = boto3.client('neptune-graph')

// Execute a query.
response = client.execute_query(
    graphIdentifier='g-0123456789',
    queryString='MATCH (n) RETURN n LIMIT 1',
    language='OPEN_CYPHER'
)

// Print the response.
print(response['payload'].read().decode('utf-8'))

Run the sample code by entering python queryExample.py.

Follow the installation instructions to install Go and the AWS SDK for Go.

Create a file named queryExample.go.

In that file, paste the following code. It will set up a Neptune graph client, execute an openCypher query request, and print the result. Replace the graph identifier and query string as needed.

package main

import (
        "context"
        "log"
        "github.com/aws/aws-sdk-go-v2/aws"
        "github.com/aws/aws-sdk-go-v2/config"
        "github.com/aws/aws-sdk-go-v2/service/neptunegraph"
        "io"
)

func main() {
        // Load the Shared AWS Configuration (~/.aws/config)
        cfg, err := config.LoadDefaultConfig(context.TODO())
        if err != nil {
                log.Fatal(err)
        }

        // Create an Amazon Neptune Analytics service client
        client := neptunegraph.NewFromConfig(cfg)

        // Execute a query
        output, err := client.ExecuteQuery(context.TODO(), &neptunegraph.ExecuteQueryInput{
                GraphIdentifier: aws.String("g-0123456789"),
                Language: "OPEN_CYPHER",
                QueryString: aws.String("MATCH (n) RETURN n LIMIT 1"),
        })
        if err != nil {
                log.Fatal(err)
        }

        // Print the results
        bytes, err := io.ReadAll(output.Payload)
        log.Println(string(bytes))
}

Run the sample code by entering go run queryExample.go.

Follow the installation instructions to install Node.js and set up your package structure. For this example, install the Neptune graph client package instead of the Amazon S3 client package: npm install @aws-sdk/client-neptune-graph.

Create a file in that directory structure named queryExample.js.

In that file, paste the following code. It will set up a Neptune graph client, execute an openCypher query request, and print the result. Replace the graph identifier and query string as needed.

import { NeptuneGraphClient, ExecuteQueryCommand } from "@aws-sdk/client-neptune-graph";

// Set up the client.
const neptuneGraphClient = new NeptuneGraphClient({});
  
// Send the query request.
const output = await neptuneGraphClient.send(
    new ExecuteQueryCommand({
        graphIdentifier: "g-0123456789",
        language: "OPEN_CYPHER",
        queryString: "MATCH (n) RETURN n LIMIT 1"
    })
);

// Print the result.
console.log(await output.payload.transformToString('utf-8'));

Run the sample code by entering node queryExample.js.

To get started with the Java SDK, follow the installation instructions to install Java and set up a build tool that supports Maven central. This example will use Apache Maven.

Follow the steps to create a project using Maven based on the quickstart template. When executing these steps, please make the following modifications:

mvn archetype:generate \
  -DarchetypeGroupId=software.amazon.awssdk \
  -DarchetypeArtifactId=archetype-app-quickstart \
  -DarchetypeVersion=2.25.7

Running the command above will present you with several prompts. When asked to provide a 'service' (i.e., the service whose client and APIs you plan to use for this tutorial), please enter neptunegraph as the service name. An updated table of prompts and values can be found below:

After generating the project structure, you should see three Maven-generated classes defined in the getstarted/src/main/java/org/example/ directory: App.java, DependencyFactory.java, and Handler.java. For details on each of these classes, see step 3 in the SDK for Java guide. Since this example uses the neptunegraph service, the Maven-generated code in the DependencyFactor and Handler classes will be using a different client than the code samples provided there. Refer to the Neptune graph-specific equivalents of the auto-generated classes below:

Make changes to the Maven-generated handler class to fill in the missing logic in sendRequest to use the NeptuneGraphClient to execute a query, then print the result. Copy the completed code below, which replaces the TODO with code and adds the necessary imports. Replace the graph identifier and query string as needed.

package org.example;

import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.services.neptunegraph.NeptuneGraphClient;
import software.amazon.awssdk.services.neptunegraph.model.ExecuteQueryRequest;
import software.amazon.awssdk.services.neptunegraph.model.ExecuteQueryResponse;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


public class Handler {
    private final NeptuneGraphClient neptuneGraphClient;

    public Handler() {
        neptuneGraphClient = DependencyFactory.neptuneGraphClient();
    }

    public void sendRequest() {
        String graphIdentifier = "g-0123456789";
        String queryString = "MATCH (n) RETURN n LIMIT 1";

        ExecuteQueryRequest request = ExecuteQueryRequest.builder()
                .graphIdentifier(graphIdentifier)
                .queryString(queryString)
                .build();

        System.out.println("Executing query: " + queryString);

        ResponseInputStream<ExecuteQueryResponse> response = neptuneGraphClient.executeQuery(request);
        BufferedReader reader = new BufferedReader(new InputStreamReader(response));

        try {
                System.out.println("Printing query result:");
                String line;
                while ((line = reader.readLine()) != null) {
                        System.out.println(line);
                }
        } catch (IOException e) {
                System.out.println("Error occurred while printing result.");
        }
    }
}

Navigate to your project directory getStarted.

Build your project: mvn clean package

Run the application: mvn exec:java -Dexec.mainClass="org.example.App".