Chapter 7: Transport Protocols

library(astraea)

# Connect via JSON-TCP (default port 7687)
client <- AstraeaClient$new("localhost", port = 7687)
client$connect()

# Ping the server
response <- client$ping()
print(response)

# Run a GQL query
results <- client$gql_query("MATCH (n:Person) RETURN n.name LIMIT 10")
print(results)

package main

import (
    "fmt"
    "log"
    astraea "github.com/AstraeaDB/AstraeaDB-Official"
)

func main() {
    // Connect via JSON-TCP (default port 7687)
    client, err := astraea.NewJSONClient("localhost", 7687)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    // Ping the server
    pong, _ := client.Ping()
    fmt.Println(pong)

    // Run a GQL query
    results, _ := client.GqlQuery("MATCH (n:Person) RETURN n.name LIMIT 10")
    for _, row := range results {
        fmt.Println(row)
    }
}

import com.astraeadb.client.JsonClient;

public class TcpExample {
    public static void main(String[] args) {
        // Connect via JSON-TCP (default port 7687)
        JsonClient client = new JsonClient("localhost", 7687);
        client.connect();

        // Ping the server
        String pong = client.ping();
        System.out.println(pong);

        // Run a GQL query
        List<Map<String, Object>> results =
            client.gqlQuery("MATCH (n:Person) RETURN n.name LIMIT 10");
        results.forEach(System.out::println);
    }
}

import com.astraeadb.client.GrpcClient;

public class GrpcExample {
    public static void main(String[] args) {
        // Connect to gRPC port
        GrpcClient client = new GrpcClient("localhost", 7688);
        client.connect();

        // Ping
        String version = client.ping();
        System.out.println("Version: " + version);

        // Create a node
        String nodeId = client.createNode(
            List.of("Person"),
            Map.of("name", "Alice", "age", 30)
        );
        System.out.println("Node ID: " + nodeId);

        // GQL query
        List<Map<String, Object>> results =
            client.gqlQuery("MATCH (n:Person) RETURN n.name");
        results.forEach(System.out::println);

        client.close();
    }
}

# Python: gRPC via generated stubs
# pip install grpcio grpcio-tools
import grpc
from astraeadb.proto import astraeadb_pb2, astraeadb_pb2_grpc

channel = grpc.insecure_channel("localhost:7688")
stub = astraeadb_pb2_grpc.AstraeaDBStub(channel)

# Ping
pong = stub.Ping(astraeadb_pb2.PingRequest())
print("Version:", pong.version)

# Create a node
resp = stub.CreateNode(astraeadb_pb2.CreateNodeRequest(
    labels=["Person"],
    properties='{"name":"Alice","age":30}'
))
print("Node ID:", resp.node_id)

# R does not have native gRPC support.
# Use the JSON-TCP client (AstraeaClient) for R workflows.
# If you need gRPC from R, call the Python stubs via reticulate:

library(reticulate)
grpc <- import("grpc")
pb   <- import("astraeadb.proto.astraeadb_pb2")
stub_mod <- import("astraeadb.proto.astraeadb_pb2_grpc")

channel <- grpc$insecure_channel("localhost:7688")
stub    <- stub_mod$AstraeaDBStub(channel)

pong <- stub$Ping(pb$PingRequest())
print(pong$version)

library(arrow)
library(astraea)

# Connect to Arrow Flight endpoint
client <- ArrowFlightClient$new("grpc://localhost:50051")

# do_get: execute GQL and receive an Arrow Table
tbl <- client$query("MATCH (n:Person) RETURN n.name, n.age")

# Convert to a base R data.frame
df <- as.data.frame(tbl)
print(df)

# do_put: bulk import a data.frame as nodes
new_people <- data.frame(
  name   = c("Dave", "Eve"),
  age    = c(28L, 32L),
  _label = c("Person", "Person")
)
client$put(new_people)

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/apache/arrow/go/v17/arrow/flight"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

func main() {
    // Connect to Arrow Flight endpoint
    client, err := flight.NewClientWithMiddleware(
        "localhost:7689",
        nil,
        nil,
        grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    ctx := context.Background()

    // do_get: execute a GQL query
    desc := &flight.FlightDescriptor{
        Type: flight.DescriptorCMD,
        Cmd:  []byte("MATCH (n:Person) RETURN n.name, n.age"),
    }
    info, _ := client.GetFlightInfo(ctx, desc)

    stream, _ := client.DoGet(ctx, info.Endpoint[0].Ticket)
    for {
        record, err := stream.Recv()
        if err != nil {
            break
        }
        fmt.Println(record)
    }
}

import org.apache.arrow.flight.*;
import org.apache.arrow.memory.RootAllocator;

public class ArrowFlightExample {
    public static void main(String[] args) {
        RootAllocator allocator = new RootAllocator();
        FlightClient client = FlightClient.builder(
            allocator,
            Location.forGrpcInsecure("localhost", 7689)
        ).build();

        // do_get: execute GQL and receive Arrow RecordBatches
        FlightInfo info = client.getInfo(
            FlightDescriptor.command(
                "MATCH (n:Person) RETURN n.name, n.age".getBytes()
            )
        );

        FlightStream stream = client.getStream(
            info.getEndpoints().get(0).getTicket()
        );

        while (stream.next()) {
            System.out.println(stream.getRoot().contentToTSVString());
        }

        client.close();
        allocator.close();
    }
}

library(astraea)

# Auto-selects the best available protocol
client <- AstraeaClient$new("localhost", auto = TRUE)
client$connect()

cat("Using protocol:", client$protocol, "\n")

# All the same methods work regardless of protocol
results <- client$gql_query("MATCH (n) RETURN n LIMIT 5")

package main

import (
    "fmt"
    "log"
    astraea "github.com/AstraeaDB/AstraeaDB-Official"
)

func main() {
    // Auto-selects the best available protocol
    client, err := astraea.NewAutoClient("localhost")
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    fmt.Println("Using protocol:", client.Protocol())

    results, _ := client.GqlQuery("MATCH (n) RETURN n LIMIT 5")
    fmt.Println(results)
}

import com.astraeadb.client.UnifiedClient;

public class UnifiedExample {
    public static void main(String[] args) {
        // Auto-selects the best available protocol
        UnifiedClient client = new UnifiedClient("localhost");
        client.connect();

        System.out.println("Using: " + client.getProtocol());

        var results = client.gqlQuery("MATCH (n) RETURN n LIMIT 5");
        results.forEach(System.out::println);

        client.close();
    }
}