Use the Java client

import com.relate.ClientException;
import com.relate.Database;
import java.nio.file.Files;
import java.nio.file.Path;

public class Open {
    static final String TEAM = """
        CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
               (grace:Person {name: 'Grace', role: 'engineer'}),
               (noor:Person {name: 'Noor', role: 'maintainer'}),
               (relate:Project {name: 'relate', language: 'Rust'}),
               (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
               (ada)-[:WORKS_ON {since: 2024}]->(relate),
               (grace)-[:WORKS_ON {since: 2023}]->(relate),
               (grace)-[:WORKS_ON {since: 2022}]->(tck),
               (noor)-[:MAINTAINS]->(relate),
               (ada)-[:KNOWS]->(grace)
        """;

    public static void main(String[] args) {
        try (Database db = Database.open("./team.rl");
             Database.Connection conn = db.connect()) {
            conn.query(TEAM);
        }
        System.out.println("team.rl exists: " + Files.exists(Path.of("team.rl")));

        try (Database db = Database.openReadOnly("./team.rl");
             Database.Connection conn = db.connect()) {
            var people = conn.query("MATCH (p:Person) RETURN count(p) AS people");
            System.out.println("people: " + people.rows().get(0).get(0));
            try {
                conn.query("CREATE (:Person {name: 'Lin'})");
            } catch (ClientException e) {
                System.out.println("refused: " + e.getGqlStatus() + " " + e.getCode());
            }
        }
    }
}

import com.relate.Database;
import com.relate.Node;
import com.relate.VectorValue;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;

public class Params {
    static final String TEAM = """
        CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
               (grace:Person {name: 'Grace', role: 'engineer'}),
               (noor:Person {name: 'Noor', role: 'maintainer'}),
               (relate:Project {name: 'relate', language: 'Rust'}),
               (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
               (ada)-[:WORKS_ON {since: 2024}]->(relate),
               (grace)-[:WORKS_ON {since: 2023}]->(relate),
               (grace)-[:WORKS_ON {since: 2022}]->(tck),
               (noor)-[:MAINTAINS]->(relate),
               (ada)-[:KNOWS]->(grace)
        """;

    public static void main(String[] args) {
        try (Database db = Database.open(":memory:");
             Database.Connection conn = db.connect()) {
            conn.query(TEAM);

            var team = conn.query("""
                MATCH (p:Person)-[w:WORKS_ON]->(:Project {name: $project})
                RETURN p, w.since AS since ORDER BY since""",
                Map.of("project", "relate"));
            for (List<Object> row : team.rows()) {
                Node person = (Node) row.get(0);
                Long since = (Long) row.get(1);
                System.out.println(person.properties().get("name") + " " + person.labels() + " since " + since);
            }

            var noor = conn.query("""
                MATCH (p:Person {name: $name})
                SET p.joined = $joined, p.focus = $focus
                RETURN p.joined AS joined, p.focus AS focus, elementId(p) AS id""",
                Map.of("name", "Noor",
                       "joined", LocalDate.of(2025, 3, 1),
                       "focus", new VectorValue("FLOAT32", List.of(0.25, 0.5, 1.0))));
            List<Object> row = noor.rows().get(0);
            System.out.println(row.get(0).getClass().getSimpleName() + " " + row.get(0));
            System.out.println(row.get(1));

            var byId = conn.query("MATCH (p) WHERE elementId(p) = $id RETURN p.name AS name",
                Map.of("id", row.get(2)));
            System.out.println("by element id: " + byId.rows().get(0).get(0));
        }
    }
}

import com.relate.ClientException;
import com.relate.Database;
import com.relate.RelateException;
import java.util.function.Consumer;

public class Transactions {
    static final String TEAM = """
        CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
               (grace:Person {name: 'Grace', role: 'engineer'}),
               (noor:Person {name: 'Noor', role: 'maintainer'}),
               (relate:Project {name: 'relate', language: 'Rust'}),
               (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
               (ada)-[:WORKS_ON {since: 2024}]->(relate),
               (grace)-[:WORKS_ON {since: 2023}]->(relate),
               (grace)-[:WORKS_ON {since: 2022}]->(tck),
               (noor)-[:MAINTAINS]->(relate),
               (ada)-[:KNOWS]->(grace)
        """;

    static String inTransaction(Database.Connection conn, Consumer<Integer> work) {
        for (int attempt = 1; ; attempt++) {
            conn.begin();
            try {
                work.accept(attempt);
                return conn.commit();
            } catch (RelateException e) {
                try {
                    conn.rollback();
                } catch (ClientException ended) {
                    // a failed commit has already ended the transaction
                }
                if (!e.isRetryable() || attempt == 3) {
                    throw e;
                }
                System.out.println("attempt " + attempt + ": " + e.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        try (Database db = Database.open(":memory:");
             Database.Connection conn = db.connect();
             Database.Connection other = db.connect()) {
            conn.query(TEAM);

            conn.begin();
            conn.query("MATCH (n:Person {name: 'Noor'}), (t:Project {name: 'opencypher-tck'}) "
                + "CREATE (n)-[:WORKS_ON {since: 2025}]->(t)");
            conn.query("MATCH (n:Person {name: 'Noor'}) SET n.role = 'engineer'");
            System.out.println("committed: " + conn.commit());

            conn.begin();
            conn.query("MATCH (a:Person {name: 'Ada'}) DETACH DELETE a");
            conn.rollback();
            System.out.println("people: " + conn.query("MATCH (p:Person) RETURN count(p)").rows().get(0).get(0));

            String bookmark = inTransaction(conn, attempt -> {
                conn.query("MATCH (p:Project {name: 'relate'}) SET p.reviews = coalesce(p.reviews, 0) + 1");
                if (attempt == 1) {
                    other.query("MATCH (p:Project {name: 'relate'}) SET p.reviews = 10");
                }
            });
            var reviews = conn.query("MATCH (p:Project {name: 'relate'}) RETURN p.reviews").rows().get(0).get(0);
            System.out.println("committed: " + bookmark + ", reviews: " + reviews);
        }
    }
}

import com.relate.Database;
import com.relate.Notification;

public class Metadata {
    static final String TEAM = """
        CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
               (grace:Person {name: 'Grace', role: 'engineer'}),
               (noor:Person {name: 'Noor', role: 'maintainer'}),
               (relate:Project {name: 'relate', language: 'Rust'}),
               (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
               (ada)-[:WORKS_ON {since: 2024}]->(relate),
               (grace)-[:WORKS_ON {since: 2023}]->(relate),
               (grace)-[:WORKS_ON {since: 2022}]->(tck),
               (noor)-[:MAINTAINS]->(relate),
               (ada)-[:KNOWS]->(grace)
        """;

    static void show(String label, Database.Result r) {
        System.out.println(label + ": type=" + r.getQueryType() + " namespace=" + r.getNamespace()
            + " bookmark=" + r.getBookmark() + " columns=" + r.columns());
    }

    public static void main(String[] args) {
        try (Database db = Database.open(":memory:");
             Database.Connection conn = db.connect()) {
            show("create", conn.query(TEAM));
            show("read", conn.query("MATCH (p:Person) RETURN p.name AS name"));
            show("update", conn.query("MATCH (p:Person {name: 'Ada'}) SET p.role = 'lead' RETURN p.role AS role"));
            show("index", conn.query("CREATE INDEX person_name FOR (p:Person) ON (p.name)"));
            show("routed", conn.query("USE system SHOW DATABASES YIELD name RETURN name"));

            var explained = conn.query("EXPLAIN MATCH (a:Person), (b:Project) RETURN a.name, b.name");
            System.out.println("plan root: " + explained.getPlan().root.operator);
            for (Notification n : explained.getNotifications()) {
                System.out.println(n.getGqlStatus() + " " + n.getSeverity() + " " + n.getTitle());
                System.out.println("remedy: " + n.getRemedy());
            }
        }
    }
}

import com.relate.ClientException;
import com.relate.Database;
import com.relate.RelateException;
import java.util.Map;

public class Errors {
    static final String TEAM = """
        CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
               (grace:Person {name: 'Grace', role: 'engineer'}),
               (noor:Person {name: 'Noor', role: 'maintainer'}),
               (relate:Project {name: 'relate', language: 'Rust'}),
               (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
               (ada)-[:WORKS_ON {since: 2024}]->(relate),
               (grace)-[:WORKS_ON {since: 2023}]->(relate),
               (grace)-[:WORKS_ON {since: 2022}]->(tck),
               (noor)-[:MAINTAINS]->(relate),
               (ada)-[:KNOWS]->(grace)
        """;

    public static void main(String[] args) {
        Database db = Database.open(":memory:");
        Database.Connection conn = db.connect();
        conn.query(TEAM);
        try {
            conn.query("MATCH (p:Person {name: $name}) RETURN p.role AS role");
        } catch (ClientException e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
            System.out.println("code: " + e.getCode());
            System.out.println("gql_status: " + e.getGqlStatus() + ", stage: " + e.getStage()
                + ", retryable: " + e.isRetryable());
        }
        System.out.println(conn.query("MATCH (p:Person {name: $name}) RETURN p.role AS role",
            Map.of("name", "Noor")).rows().get(0).get(0));

        conn.close();
        db.close();
        try {
            conn.query("RETURN 1");
        } catch (RelateException e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage() + ", code: " + e.getCode());
        }
    }
}

import com.relate.Database;

public class Verify {
    public static void main(String[] args) {
        try (Database db = Database.open(":memory:");
             Database.Connection conn = db.connect()) {
            var result = conn.query("CALL dbms.components() YIELD name, versions "
                + "WHERE name = 'Relate' RETURN versions[0] AS version");
            System.out.println("relate " + result.rows().get(0).get(0));
        }
    }
}