ArcadeDB Developer Center

from arcadedb_driver import ArcadeDBServer, basic_auth

with ArcadeDBServer(base_url="http://localhost:2480", auth=basic_auth("root", "playwithdata")) as srv:
    db = srv.db("mydb")
    db.command(language="cypher",
               command="CREATE (:Person {name: $a})-[:KNOWS]->(:Person {name: $b})",
               params={"a": "Alice", "b": "Bob"})
    env = db.query(language="cypher",
                   command="MATCH (:Person {name: $name})-[:KNOWS]->(f) RETURN f.name AS friend",
                   params={"name": "Alice"})
    for row in env.result:  # check env.truncated before trusting a partial answer
        print(row["friend"])

import { createClient, basicAuth } from "@arcadedb/driver";

const server = createClient({ baseUrl: "http://localhost:2480", auth: basicAuth("root", "playwithdata") });
const db = server.db("mydb");

await db.command({
  language: "sqlscript",
  command: `CREATE VERTEX TYPE Person IF NOT EXISTS; CREATE EDGE TYPE KNOWS IF NOT EXISTS;
    LET a = CREATE VERTEX Person SET name = :a; LET b = CREATE VERTEX Person SET name = :b;
    CREATE EDGE KNOWS FROM $a TO $b;`,
  params: { a: "Alice", b: "Bob" },
});
const { result, truncated } = await db.query({
  language: "cypher",
  command: "MATCH (:Person {name: $name})-[:KNOWS]->(f) RETURN f.name AS friend",
  params: { name: "Alice" },
});
console.log(result.map((row) => row.friend), truncated);

ctx := context.Background()
srv, err := arcadedb.NewServer("http://localhost:2480", arcadedb.WithBasicAuth("root", "playwithdata"))
if err != nil {
	log.Fatal(err)
}
defer srv.Close()
db := srv.DB("mydb")

_, err = db.Command(ctx, arcadedb.Cypher,
	"CREATE (:Person {name: $a})-[:KNOWS]->(:Person {name: $b})", map[string]any{"a": "Alice", "b": "Bob"})
if err != nil {
	log.Fatal(err)
}
env, err := db.Query(ctx, arcadedb.Cypher,
	"MATCH (:Person {name: $name})-[:KNOWS]->(f) RETURN f.name AS friend", map[string]any{"name": "Alice"})
if err != nil {
	log.Fatal(err)
}
for _, row := range env.Result { // check env.Truncated before trusting a partial answer
	fmt.Println(row["friend"])
}

using Neo4j.Driver;

await using var driver = GraphDatabase.Driver("bolt://localhost:7687",
    AuthTokens.Basic("root", "playwithdata"));
await using var session = driver.AsyncSession(o => o.WithDatabase("mydb"));

await session.RunAsync("CREATE (:Person {name: $a})-[:KNOWS]->(:Person {name: $b})",
    new { a = "Alice", b = "Bob" });
var cursor = await session.RunAsync(
    "MATCH (:Person {name: $name})-[:KNOWS]->(f) RETURN f.name AS friend", new { name = "Alice" });
await foreach (var record in cursor)
    Console.WriteLine(record["friend"].As<string>());

# Create two people and an edge
curl -X POST http://localhost:2480/api/v1/command/mydb -u root:playwithdata \
  -H "Content-Type: application/json" \
  -d '{"language":"cypher","command":"CREATE (:Person {name: $a})-[:KNOWS]->(:Person {name: $b})","params":{"a":"Alice","b":"Bob"}}'

# Who does Alice know?
curl -X POST http://localhost:2480/api/v1/query/mydb -u root:playwithdata \
  -H "Content-Type: application/json" \
  -d '{"language":"cypher","command":"MATCH (:Person {name: $name})-[:KNOWS]->(f) RETURN f.name AS friend","params":{"name":"Alice"}}'