RyuGraph

https://ryugraph.io/docs
Admin
RyuGraph is an embedded, open-source graph database optimized for fast, scalable, analytical...
Tokens:163,063
Snippets:1,501
Trust Score:3.6
Update:11 months ago
Show doc for...
Tokens:
Raw
### Download Example Data with cURL

Source: https://ryugraph.io/docs/get-started

This snippet downloads example CSV files required for Ryugraph demonstrations from the official GitHub repository using cURL. Ensure you have cURL installed and a directory named 'data' to store these files.

```shell
mkdir ./data/
curl -L -o ./data/city.csv https://raw.githubusercontent.com/predictable-labs/ryugraph/refs/heads/master/dataset/demo-db/csv/city.csv
curl -L -o ./data/user.csv https://raw.githubusercontent.com/predictable-labs/ryugraph/refs/heads/master/dataset/demo-db/csv/user.csv
curl -L -o ./data/follows.csv https://raw.githubusercontent.com/predictable-labs/ryugraph/refs/heads/master/dataset/demo-db/csv/follows.csv
curl -L -o ./data/lives-in.csv https://raw.githubusercontent.com/predictable-labs/ryugraph/refs/heads/master/dataset/demo-db/csv/lives-in.csv
```

--------------------------------

### Install and Use Ryugraph Client Library (Node.js)

Source: https://ryugraph.io/docs/get-started

Demonstrates how to install and use the Ryugraph Node.js client to create a database, define node and relationship tables, load data from CSV files, and execute queries. The example shows creating 'User', 'City', 'Follows', and 'LivesIn' tables and querying for user follow relationships.

```javascript
const ryugraph = require("ryugraph");

(async () => {
  // Create an empty on-disk database and connect to it
  const db = new ryugraph.Database("example.ryugraph");
  const conn = new ryugraph.Connection(db);


  // Create the tables
  await conn.query("CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)");
  await conn.query("CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)");
  await conn.query("CREATE REL TABLE Follows(FROM User TO User, since INT64)");
  await conn.query("CREATE REL TABLE LivesIn(FROM User TO City)");


  // Load the data
  await conn.query('COPY User FROM "./data/user.csv"');
  await conn.query('COPY City FROM "./data/city.csv"');
  await conn.query('COPY Follows FROM "./data/follows.csv"');
  await conn.query('COPY LivesIn FROM "./data/lives-in.csv"');


  const queryResult = await conn.query("MATCH (a:User)-[f:Follows]->(b:User) RETURN a.name, f.since, b.name;");


  // Get all rows from the query result
  const rows = await queryResult.getAll();


  // Print the rows
  for (const row of rows) {
    console.log(row);
  }
})();
```

--------------------------------

### Ryugraph C++ Client Setup and Example

Source: https://ryugraph.io/docs/get-started

This C++ code demonstrates how to initialize the Ryugraph database, create node and relationship tables, load data from CSV files, and execute a graph traversal query. It includes error handling for query execution and iterates through the results. Dependencies include the ryugraph library and standard C++ libraries.

```cpp
#include <iostream>

#include "include/ryugraph.hpp"

using namespace ryugraph::main;
using namespace std;

unique_ptr<QueryResult> runQuery(const string_view &query, unique_ptr<Connection> &connection) {
    auto results = connection->query(query);
    if (!results->isSuccess()) {
        throw std::runtime_error(results->getErrorMessage());
    }
    return results;
}


int main() {
    // Remove example.ryugraph
    remove("example.ryugraph");
    remove("example.ryugraph.wal");


    // Create an empty on-disk database and connect to it
    SystemConfig systemConfig;
    auto database = make_unique<Database>("example.ryugraph", systemConfig);
    auto connection = make_unique<Connection>(database.get());


    // Create the schema.
    runQuery("CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)", connection);
    runQuery("CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)", connection);
    runQuery("CREATE REL TABLE Follows(FROM User TO User, since INT64)", connection);
    runQuery("CREATE REL TABLE LivesIn(FROM User TO City)", connection);


    // Load data.
    runQuery("COPY User FROM 'data/user.csv'", connection);
    runQuery("COPY City FROM 'data/city.csv'", connection);
    runQuery("COPY Follows FROM 'data/follows.csv'", connection);
    runQuery("COPY LivesIn FROM 'data/lives-in.csv'", connection);


    // Execute a simple query.
    auto result = runQuery("MATCH (a:User)-[f:Follows]->(b:User) RETURN a.name, f.since, b.name;", connection);


    // Output query result.
    while (result->hasNext()) {
        auto row = result->getNext();
        std::cout
            << row->getValue(0)->getValue<string>() << " | "
            << row->getValue(1)->getValue<int64_t>() << " | "
            << row->getValue(2)->getValue<string>() << std::endl;
    }
    return 0;
}

```

--------------------------------

### Initialize Ryugraph Database and Create Tables (Rust)

Source: https://ryugraph.io/docs/get-started

Shows the initial setup for using the Ryugraph Rust client. It demonstrates how to create a new on-disk database and establish a connection. This is the starting point for interacting with Ryugraph from a Rust application. Ensure the 'ryugraph' crate is added to your Cargo.toml.

```rust
use ryugraph::{Connection, Database, Error, SystemConfig};


fn main() -> Result<(), Error> {
    // Create an empty on-disk database and connect to it
    let db = Database::new("example.ryugraph", SystemConfig::default())?;
    let conn = Connection::new(&db)?;


    // Create the tables

```

--------------------------------

### Install Ryugraph Go Client Library

Source: https://ryugraph.io/docs/installation

Installs the Ryugraph Go client library using go get command. Version v0.11.0 is specified for the latest stable release. Requires an initialized Go project with a go.mod file.

```shell
go get github.com/predictable-labs/go-ryugraph@v0.11.0
```

--------------------------------

### Initialize Ryugraph Database and Create Schema in C

Source: https://ryugraph.io/docs/get-started

Initializes an on-disk Ryugraph database, establishes a connection, and creates the database schema with User and City node tables and Follows/LivesIn relationship tables. Demonstrates basic database setup using the Ryugraph C API with proper resource initialization and cleanup.

```c
#include <stdio.h>
#include "include/ryugraph.h"

int main()
{
    // Create an empty on-disk database and connect to it
    ryugraph_database db;
    ryugraph_database_init("example.ryugraph", ryugraph_default_system_config(), &db);

    // Connect to the database.
    ryugraph_connection conn;
    ryugraph_connection_init(&db, &conn);

    // Create the schema.
    ryugraph_query_result result;
    ryugraph_connection_query(&conn, "CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)", &result);
    ryugraph_query_result_destroy(&result);
    ryugraph_connection_query(&conn, "CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)", &result);
    ryugraph_query_result_destroy(&result);
    ryugraph_connection_query(&conn, "CREATE REL TABLE Follows(FROM User TO User, since INT64)", &result);
    ryugraph_query_result_destroy(&result);
    ryugraph_connection_query(&conn, "CREATE REL TABLE LivesIn(FROM User TO City)", &result);
    ryugraph_query_result_destroy(&result);

    return 0;
}
```

--------------------------------

### Build and Link Ryugraph from Source using CMake

Source: https://ryugraph.io/docs/client-apis/c

This CMake example shows how to use FetchContent to download and build Ryugraph as a dependency. It allows linking either statically or dynamically to an example executable, configurable via the EXAMPLE_SHARED option. Ensure Get Started provides an example for main.c.

```cmake
cmake_minimum_required(VERSION 3.11)
project(example LANGUAGES C CXX)
set(BUILD_SHELL FALSE)
include(FetchContent)
FetchContent_Declare(ryugraph
    URL https://github.com/predictable-labs/ryugraph/archive/refs/tags/v0.5.0.zip
    URL_HASH SHA256=47ff308079cbbfeccc38eeb1c5f455a8c00f9294034141b9084387518f0bbed9
)
FetchContent_MakeAvailable(ryugraph)
add_executable(example main.c)
option(EXAMPLE_SHARED "Use dynamic linking" TRUE)
if (EXAMPLE_SHARED)
  target_link_libraries(example ryugraph_shared)
else()
  target_link_libraries(example ryugraph)
endif()

```

--------------------------------

### Initialize Ryugraph DB, Create Schema, Import Data, and Query (Python)

Source: https://ryugraph.io/docs/get-started

This Python script demonstrates how to initialize an on-disk Ryugraph database, define node and relationship schemas, import data from CSV files, and execute a Cypher query. It requires the 'ryugraph' library to be installed.

```python
import ryugraph

def main():
    # Create an empty on-disk database and connect to it
    db = ryugraph.Database("example.ryugraph")
    conn = ryugraph.Connection(db)


    # Create schema
    conn.execute("CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)")
    conn.execute("CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)")
    conn.execute("CREATE REL TABLE Follows(FROM User TO User, since INT64)")
    conn.execute("CREATE REL TABLE LivesIn(FROM User TO City)")


    # Insert data
    conn.execute('COPY User FROM "./data/user.csv"')
    conn.execute('COPY City FROM "./data/city.csv"')
    conn.execute('COPY Follows FROM "./data/follows.csv"')
    conn.execute('COPY LivesIn FROM "./data/lives-in.csv"')


    # Execute Cypher query
    response = conn.execute(
        """
        MATCH (a:User)-[f:Follows]->(b:User)
        RETURN a.name, b.name, f.since;
        """
    )
    for row in response:
        print(row)


if __name__ == "__main__":
    main()
```

--------------------------------

### Create Ryugraph Database Schema and Load Data (Java)

Source: https://ryugraph.io/docs/get-started

A Java example demonstrating how to initialize a Ryugraph database, create node and relationship tables, load data from CSV files, and execute a query to retrieve user follow relationships. This code is intended to be run within a Gradle project structure.

```java
import com.ryugraphdb.*;


public class Main {
    public static void main(String[] args) throws ObjectRefDestroyedException {
        // Create an empty on-disk database and connect to it
        Database db = new Database("example.ryugraph");
        Connection conn = new Connection(db);
        // Create tables.
        conn.query("CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)");
        conn.query("CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)");
        conn.query("CREATE REL TABLE Follows(FROM User TO User, since INT64)");
        conn.query("CREATE REL TABLE LivesIn(FROM User TO City)");
        // Load data.
        conn.query("COPY User FROM 'src/main/resources/user.csv'");
        conn.query("COPY City FROM 'src/main/resources/city.csv'");
        conn.query("COPY Follows FROM 'src/main/resources/follows.csv'");
        conn.query("COPY LivesIn FROM 'src/main/resources/lives-in.csv'");


        // Execute a simple query.
        QueryResult result =
                conn.query("MATCH (a:User)-[f:Follows]->(b:User) RETURN a.name, f.since, b.name;");
        while (result.hasNext()) {
            FlatTuple row = result.getNext();
            System.out.print(row);
        }
    }
}
```

--------------------------------

### Install Polars for Ryugraph IO

Source: https://ryugraph.io/docs/get-started

This command installs the Polars library, a fast DataFrame library for Python, which is essential for efficient data manipulation within the Ryugraph IO project. Ensure you have pip installed.

```bash
pip install polars
```

--------------------------------

### Initialize Swift Project and Add Ryugraph Dependency

Source: https://ryugraph.io/docs/get-started

Demonstrates how to create a new Swift executable project and configure its `Package.swift` file to include the `ryugraph-swift` library as a dependency. This sets up the project for using Ryugraph functionalities in Swift.

```bash
mkdir ryugraph-swift-example
cd ryugraph-swift-example
swift package init --type=executable
```

```swift
import PackageDescription


let package = Package(
    name: "ryugraph-swift-example",
    platforms: [
        .macOS(.v11),
        .iOS(.v14),
    ],
    dependencies: [
        .package(url: "https://github.com/predictable-labs/ryugraph-swift/", branch: "0.11.0"),
    ],
    targets: [
        // Targets are the basic building blocks of a package, defining a module or a test suite.
        // Targets can depend on other targets in this package and products from dependencies.
        .executableTarget(
            name: "ryugraph-swift-example",
            dependencies: [
                .product(name: "Ryugraph", package: "ryugraph-swift"),
            ]
        ),
    ]
)
```

--------------------------------

### Run Ryugraph CLI via Nix

Source: https://ryugraph.io/docs/installation

Executes Ryugraph CLI in a temporary Nix shell or installs it declaratively using NixOS or Home Manager configuration. Supports Linux, macOS, and WSL2 environments.

```shell
nix-shell -p ryugraph
ryugraph
```

```nix
{
  environment.systemPackages = [ pkgs.ryugraph ]; // NixOS
  home.packages = [ pkgs.ryugraph ];              // Home Manager
}
```

--------------------------------

### Build and Copy Swift Executable

Source: https://ryugraph.io/docs/get-started

Provides commands to compile a Swift project in release mode and then copy the resulting executable to the project's root directory. This ensures the executable can be run from the top level and access necessary data files.

```bash
swift build -c release
cp ./.build/arm64-apple-macosx/release/ryugraph-swift-example .
```

--------------------------------

### Install Ryugraph C/C++ Client Library

Source: https://ryugraph.io/docs/installation

Downloads the Ryugraph C/C++ binaries for Linux, macOS, or Windows using curl. The distribution includes compiled library files (so/dylib/dll+lib) and header file (ryugraph.hpp). Link the directory to your C++ program's build system search paths.

```shell
curl -L -O https://github.com/predictable-labs/ryugraph/releases/download/v0.11.0/ryugraph_cli-[platform]-[arch].tar.gz
```

--------------------------------

### Download and Unzip Tutorial Data using Curl

Source: https://ryugraph.io/docs/tutorials/example-database

This snippet demonstrates how to download a zipped dataset using curl and then unzip it to the current directory. It requires curl and unzip utilities to be installed.

```bash
curl -o tutorial_data.zip https://ryugraphdb.github.io/data/tutorial/tutorial_data.zip
unzip tutorial_data.zip
```

--------------------------------

### Install Ryugraph Node.js Client Library

Source: https://ryugraph.io/docs/installation

Installs the Ryugraph Node.js client library using npm. Requires Node.js and npm to be installed on the system. The package will be added to the project's package.json dependencies.

```shell
npm install ryugraph
```

--------------------------------

### Install Ryugraph Python Client Library

Source: https://ryugraph.io/docs/installation

Installs the Ryugraph Python client library using uv, pip, or nix package managers. Works identically across Linux, macOS, and Windows. Choose the package manager that fits your Python project setup.

```shell
uv init
uv add ryugraph
```

```shell
pip install ryugraph
```

```shell
nix-shell -p "python3.withPackages (ps: [ ps.ryugraph ])"
```

--------------------------------

### Install Ryugraph Rust Client Library via Cargo

Source: https://ryugraph.io/docs/installation

Installs the Ryugraph Rust client library using Cargo. By default, builds and statically links Ryugraph's C++ library from source. Dynamic linking against release libraries is also supported as described in the crate documentation.

```shell
cargo add ryugraph
```

--------------------------------

### Create Schema and Load Data in Go

Source: https://ryugraph.io/docs/get-started

Sets up a Ryugraph database connection in Go, defines the schema for User and City nodes, and Follows and LivesIn relationships. It then loads data from CSV files and executes a Cypher query to retrieve user names and follow timestamps.

```go
package main


import (
    "fmt"

    "github.com/predictable-labs/go-ryugraph"
)


func main() {
    // Create an empty on-disk database and connect to it
    systemConfig := ryugraph.DefaultSystemConfig()
    systemConfig.BufferPoolSize = 1024 * 1024 * 1024
    db, err := ryugraph.OpenDatabase("example.ryugraph", systemConfig)
    if err != nil {
        panic(err)
    }
    defer db.Close()

    conn, err := ryugraph.OpenConnection(db)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // Create schema
    queries := []string{
        "CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)",
        "CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)",
        "CREATE REL TABLE Follows(FROM User TO User, since INT64)",
        "CREATE REL TABLE LivesIn(FROM User TO City)",
        "COPY User FROM \"./data/user.csv\"",
        "COPY City FROM \"./data/city.csv\"",
        "COPY Follows FROM \"./data/follows.csv\"",
        "COPY LivesIn FROM \"./data/lives-in.csv\"",
    }
    for _, query := range queries {
        queryResult, err := conn.Query(query)
        if err != nil {
            panic(err)
        }
        defer queryResult.Close()
    }

    // Execute Cypher query
    query := "MATCH (a:User)-[e:Follows]->(b:User) RETURN a.name, e.since, b.name"
    result, err := conn.Query(query)
    if err != nil {
        panic(err)
    }
    defer result.Close()
    for result.HasNext() {
        tuple, err := result.Next()
        if err != nil {
            panic(err)
        }
        defer tuple.Close()
        // The result is a tuple, which can be converted to a slice.
        slice, err := tuple.GetAsSlice()
        if err != nil {
            panic(err)
        }
        fmt.Println(slice)
    }
}
```

--------------------------------

### Setup Ryugraph Environment with Pip

Source: https://ryugraph.io/docs/tutorials/python

Installs Ryugraph and its dependencies within a Python virtual environment using pip. Ensures a clean and isolated environment for the project.

```bash
python -m venv .venv
source .venv/bin/activate
pip install ryugraph
```

--------------------------------

### Build and Execute Ryugraph C++ Project with CMake

Source: https://ryugraph.io/docs/get-started

Commands to build and run a Ryugraph C++ project using CMake. Creates a build directory, compiles the project, and executes the resulting binary. Works on Unix-like systems (Linux, macOS).

```bash
cmake -S . -B build
cmake --build build
./build/ryugraph-cpp
```

--------------------------------

### Add Ryugraph Swift Package via Package.swift

Source: https://ryugraph.io/docs/installation

Adds the ryugraph-swift package as a dependency in the Swift project's Package.swift file. Supports specifying branch (e.g., 0.11.0 for stable or main for development) and configuring target dependencies to include the Ryugraph product.

```swift
dependencies: [
  .package(url: "https://github.com/predictable-labs/ryugraph-swift/", branch: "0.11.0"),
]
```

```swift
targets: [
  .target(
    name: "YourTargetName",
    dependencies: [
      .product(name: "Ryugraph", package: "ryugraph-swift"),
    ]
  )
]
```

--------------------------------

### Compile and Run Ryugraph C Code on Linux

Source: https://ryugraph.io/docs/get-started

Compilation and execution commands for Ryugraph C code on Linux systems. Uses environment variables to override linker search paths (LIBRARY_PATH and LD_LIBRARY_PATH) to locate the Ryugraph library in the current directory without system installation.

```bash
env LIBRARY_PATH=. LD_LIBRARY_PATH=. gcc main.c -lryugraph
env LIBRARY_PATH=. LD_LIBRARY_PATH=. ./a.out
```

--------------------------------

### Download and Install Ryugraph CLI on Windows

Source: https://ryugraph.io/docs/installation

Downloads the Ryugraph CLI for Windows x86-64 as a zip file. The archive must be extracted manually via file explorer, and ryugraph.exe can be run from the extracted directory. Alternatively, the file can be downloaded directly via browser.

```shell
curl -L -O https://github.com/predictable-labs/ryugraph/releases/download/v0.11.0/ryugraph_cli-windows-x86_64.zip
```

--------------------------------

### Open On-Disk Database with Ryugraph CLI

Source: https://ryugraph.io/docs/get-started

Command to open an existing on-disk Ryugraph database using the Ryugraph CLI shell. Specifies the database path as an argument to establish a read-write connection to the database for interactive queries.

```bash
ryugraph example.ryugraph
```

--------------------------------

### Clone and Start Unity Catalog Server

Source: https://ryugraph.io/docs/extensions/attach/unity

Clone the open-source Unity Catalog repository and start the UC server. This is required before setting up the Ryugraph extension.

```bash
git clone https://github.com/unitycatalog/unitycatalog.git
bin/start-uc-server
```

--------------------------------

### Download and Install Ryugraph CLI on Linux

Source: https://ryugraph.io/docs/installation

Downloads the Ryugraph CLI for Linux x86-64 or aarch64 architecture using curl, extracts the tarball, and runs the executable. Supports both 64-bit and ARM64 architectures. No dependencies required for the standalone executable.

```shell
# x86-64
curl -L -O https://github.com/predictable-labs/ryugraph/releases/download/v0.11.0/ryugraph_cli-linux-x86_64.tar.gz
# aarch64
curl -L -O https://github.com/predictable-labs/ryugraph/releases/download/v0.11.0/ryugraph_cli-linux-aarch64.tar.gz

tar xzf ryugraph_cli-*.tar.gz

./ryugraph
```

--------------------------------

### Download and Install Ryugraph CLI on macOS

Source: https://ryugraph.io/docs/installation

Downloads the Ryugraph CLI for macOS universal binary (x86-64 and ARM64), extracts the archive, and runs the executable. This method works for both Intel and Apple Silicon Macs.

```shell
curl -L -O https://github.com/predictable-labs/ryugraph/releases/download/v0.11.0/ryugraph_cli-osx-universal.tar.gz
tar xzf ryugraph_cli-*.tar.gz
./ryugraph
```

--------------------------------

### Create Schema and Load Data in Rust

Source: https://ryugraph.io/docs/get-started

Initializes a Ryugraph database, defines node and relationship tables (User, City, Follows, LivesIn), and loads data from CSV files. It then executes a Cypher query to find users and their follow relationships, printing the results.

```rust
use ryugraph::{Connection, Database, SystemConfig};

fn main() -> Result<(), ryugraph::Error> {
    // Create an empty on-disk database and connect to it
    let mut systemConfig = SystemConfig::default();
    systemConfig.buffer_pool_size = 1024 * 1024 * 1024;
    let db = Database::open("example.ryugraph", systemConfig)?;
    let conn = Connection::open(db)?;

    // Create schema
    conn.query("CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)")?;
    conn.query("CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)")?;
    conn.query("CREATE REL TABLE Follows(FROM User TO User, since INT64)")?;
    conn.query("CREATE REL TABLE LivesIn(FROM User TO City)")?;

    // Load the data
    conn.query("COPY User FROM './data/user.csv'")?;
    conn.query("COPY City FROM './data/city.csv'")?;
    conn.query("COPY Follows FROM './data/follows.csv'")?;
    conn.query("COPY LivesIn FROM './data/lives-in.csv'")?;

    let query_result = conn.query("MATCH (a:User)-[f:Follows]->(b:User) RETURN a.name, f.since, b.name")?;

    // Print the rows
    for row in query_result {
        println!("{}, {}, {}\n", row[0], row[1], row[2]);
    }
    Ok(())
}
```

--------------------------------

### Compile and Run Ryugraph C Code on Windows

Source: https://ryugraph.io/docs/get-started

Compilation and execution commands for Ryugraph C code on Windows systems. Passes the library file directly to the compiler and relies on Windows runtime library search in the current directory for the ryugraph_shared.dll file.

```bash
cl main.c ryugraph_shared.lib
./main.exe
```

--------------------------------

### Launch Ryugraph Explorer with an empty database (Docker)

Source: https://ryugraph.io/docs/visualization/ryugraph-explorer

Starts Ryugraph Explorer with an empty database, useful for exploring bundled example datasets. This is achieved by omitting the volume mount (-v) flag. The server will create 'database.kz' if no file is specified.

```bash
docker run -p 8000:8000 --rm ryugraphdb/explorer:latest
```

--------------------------------

### Build and Install Ryugraph using CMake

Source: https://ryugraph.io/docs/client-apis/c

These CMake commands illustrate the process of building and installing Ryugraph. The first two commands build the project, and the third installs it to a specified prefix. This is useful for integrating the dynamic library with other build systems by linking against libryugraph.so and including the installation directory.

```bash
cmake -B build
cmake --build build
cmake --install build --prefix '<install-dest>'

```

--------------------------------

### Example Test File Structure (Before Rewrite)

Source: https://ryugraph.io/docs/developer-guide/testing-framework

Presents the initial content of a test file before the E2E_REWRITE_TESTS mode is applied. It includes dataset definition, case setup, and statements with expected outputs.

```ryugraph_test_language
-DATASET CSV empty

--

-CASE demo
-STATEMENT CREATE NODE TABLE A(ID SERIAL PRIMARY KEY, name STRING);
----
ok
-STATEMENT CREATE (:A), (:A {name: 'Alice'});
----
ok
-STATEMENT CREATE (:A), (:A {name: 'Alice'}), (:A {name: 'Bob'});
----
ok
-STATEMENT MATCH (n) RETURN n.name;
----
0

```

--------------------------------

### Add Ryugraph Java Dependency via Maven

Source: https://ryugraph.io/docs/installation

Adds the Ryugraph Java client library as a Maven dependency in the project's pom.xml file. Version 0.11.0 is the latest stable release available on Maven Central Repository.

```xml
<dependency>
  <groupId>com.ryugraphdb</groupId>
  <artifactId>ryugraph</artifactId>
  <version>0.11.0</version>
</dependency>
```

--------------------------------

### Execute Graph Query and Process Results in C

Source: https://ryugraph.io/docs/get-started

Executes a MATCH query to find user follow relationships and processes the results by iterating through tuples and extracting string and integer64 values. Demonstrates result iteration, value extraction, and proper memory management with cleanup of resources.

```c
// Execute a simple query.
ryugraph_connection_query(&conn, "MATCH (a:User)-[f:Follows]->(b:User) RETURN a.name, f.since, b.name;", &result);

// Output query result.
ryugraph_flat_tuple tuple;
ryugraph_value value;
while (ryugraph_query_result_has_next(&result))
{
    ryugraph_query_result_get_next(&result, &tuple);

    ryugraph_flat_tuple_get_value(&tuple, 0, &value);
    char *name = NULL;
    ryugraph_value_get_string(&value, &name);
    ryugraph_value_destroy(&value);

    ryugraph_flat_tuple_get_value(&tuple, 1, &value);
    int64_t since = 0;
    ryugraph_value_get_int64(&value, &since);
    ryugraph_value_destroy(&value);

    ryugraph_flat_tuple_get_value(&tuple, 2, &value);
    char *name2 = NULL;
    ryugraph_value_get_string(&value, &name2);
    ryugraph_value_destroy(&value);

    printf("%s follows %s since %lld \n", name, name2, since);
    free(name);
    free(name2);
}
ryugraph_value_destroy(&value);
ryugraph_flat_tuple_destroy(&tuple);
ryugraph_query_result_destroy(&result);
ryugraph_connection_destroy(&conn);
ryugraph_database_destroy(&db);
```

--------------------------------

### Add Ryugraph Java Client Dependency (Maven/Gradle)

Source: https://ryugraph.io/docs/get-started

Provides Maven and Gradle snippets to add the Ryugraph Java client library to a project. This allows Java applications to connect to and interact with a Ryugraph database. Ensure you are using a compatible version.

```xml
<dependency>
    <groupId>com.ryugraphdb</groupId>
    <artifactId>ryugraph</artifactId>
    <version>0.11.0</version>
</dependency>
```

```groovy
implementation 'com.ryugraphdb:ryugraph:0.11.0'
```

```kotlin
implementation("com.ryugraphdb:ryugraph:0.11.0")
```

--------------------------------

### Create Example Dataset for Ryugraph

Source: https://ryugraph.io/docs/extensions/algo

This snippet defines the schema for a 'Person' node table and a 'KNOWS' relationship table, then populates them with sample data. This setup is necessary for demonstrating projected graph creation and algorithm execution.

```cypher
CREATE NODE TABLE Person(name STRING PRIMARY KEY);
CREATE REL TABLE KNOWS(FROM Person to Person, id INT64);
CREATE  (u0:Person {name: 'Alice'}),
        (u1:Person {name: 'Bob'}),
        (u2:Person {name: 'Charlie'}),
        (u3:Person {name: 'Derek'}),
        (u4:Person {name: 'Eve'}),
        (u5:Person {name: 'Frank'}),
        (u6:Person {name: 'George'}),
        (u7:Person {name: 'Hina'}),
        (u8:Person {name: 'Ira'}),
        (u0)-[:KNOWS {id: 0}]->(u1),
        (u1)-[:KNOWS {id: 1}]->(u2),
        (u5)-[:KNOWS {id: 2}]->(u4),
        (u6)-[:KNOWS {id: 3}]->(u4),
        (u6)-[:KNOWS {id: 4}]->(u5),
        (u6)-[:KNOWS {id: 5}]->(u7),
        (u7)-[:KNOWS {id: 6}]->(u4),
        (u6)-[:KNOWS {id: 7}]->(u5);
```

--------------------------------

### Create In-Memory Database with Ryugraph CLI

Source: https://ryugraph.io/docs/get-started

Command to create a temporary in-memory Ryugraph database using the Ryugraph CLI. Omits the path argument to initialize a database that exists only in RAM and is discarded when the process terminates, useful for testing and temporary operations.

```bash
ryugraph
```

--------------------------------

### Execute Cypher Query to Find Follows

Source: https://ryugraph.io/docs/get-started

Executes a Cypher query to find users and their relationships. This specific query returns the names of users and the 'since' attribute of their 'Follows' relationship.

```cypher
MATCH (a:User)-[f:Follows]->(b:User)
RETURN a.name, b.name, f.since;
```

--------------------------------

### Create Schema using Cypher

Source: https://ryugraph.io/docs/get-started

Defines node tables (User, City) and relationship tables (Follows, LivesIn) for the graph database. Specifies primary keys and data types for node properties and relationship attributes.

```cypher
CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64);
CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64);
CREATE REL TABLE Follows(FROM User TO User, since INT64);
CREATE REL TABLE LivesIn(FROM User TO City);
```

--------------------------------

### Import Follows Relationship Data from CSV

Source: https://ryugraph.io/docs/cypher/data-manipulation-clauses/example-database

Imports data for the 'Follows' relationship from a CSV file. The file should contain pairs of user names and the year they started following each other. Update `${PATH-TO-DIR}` to the correct directory.

```SQL
COPY Follows FROM "${PATH-TO-DIR}/follows.csv"
```

--------------------------------

### Ryugraph C++ CMake Configuration

Source: https://ryugraph.io/docs/get-started

This CMakeLists.txt file configures the build process for the Ryugraph C++ project. It sets the C++ standard, defines compiler flags for Windows (including MSVC specifics like /utf-8 and /EHa) and Linux/macOS (-Wall -Wextra), and specifies output directories for libraries and executables. It also includes a workaround for a regex stack overflow issue on Windows when using gtest.

```cmake
cmake_minimum_required(VERSION 3.15)
project(ryugraph-cpp)


set(CMAKE_CXX_STANDARD 20)


if(MSVC)
    # Required for M_PI on Windows
    add_compile_definitions(_USE_MATH_DEFINES)
    add_compile_definitions(NOMINMAX)
    add_compile_definitions(SERD_STATIC)
    # Non-english windows system may use other encodings other than utf-8 (e.g. Chinese use GBK).
    add_compile_options("/utf-8")
    # Enables support for custom hardware exception handling
    add_compile_options("/EHa")
    # Reduces the size of the static library by roughly 1/2
    add_compile_options("/Zc:inline")
    # Disable type conversion warnings
    add_compile_options(/wd4244 /wd4267)
    # Remove the default to avoid warnings
    STRING(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
    STRING(REPLACE "/EHs" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
    # Store all libraries and binaries in the same directory so that ryugraph_shared.dll is found at runtime
    set(LIBRARY_OUTPUT_PATH "${CMAKE_BINARY_DIR}/src")
    set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/src")
    # This is a workaround for regex stackoverflow issue on windows in gtest.
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:8388608")


    string(REGEX REPLACE "/W[3|4]" "/w" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
    add_compile_options($<$<CONFIG:Release>:/W0>)
else()
    add_compile_options(-Wall -Wextra)
    # Disable warnings for unknown pragmas, which is used by several third-party libraries
    add_compile_options(-Wno-unknown-pragmas)
endif()


add_executable(ryugraph-cpp main.cpp)


```

--------------------------------

### Create Schema and Load Data in Swift

Source: https://ryugraph.io/docs/get-started

Initializes a Ryugraph database and connection in Swift. It defines the database schema for User and City nodes, and Follows and LivesIn relationships, then loads data from CSV files. Finally, it executes a Cypher query to retrieve and print relationship details.

```swift
import Ryugraph


// Create an empty on-disk database and connect to it
let db = try! Database("example.ryugraph")
let conn = try! Connection(db)


// Create schema and load data
let queries = [
    "CREATE NODE TABLE User(name STRING PRIMARY KEY, age INT64)",
    "CREATE NODE TABLE City(name STRING PRIMARY KEY, population INT64)",
    "CREATE REL TABLE Follows(FROM User TO User, since INT64)",
    "CREATE REL TABLE LivesIn(FROM User TO City)",
    "COPY User FROM 'data/user.csv'",
    "COPY City FROM 'data/city.csv'",
    "COPY Follows FROM 'data/follows.csv'",
    "COPY LivesIn FROM 'data/lives-in.csv'",
]


for query in queries {
    _ = try! conn.query(query)
}


// Execute Cypher query
let res = try! conn.query("MATCH (a:User)-[e:Follows]->(b:User) RETURN a.name, e.since, b.name")
for tuple in res {
    let dict = try! tuple.getAsDictionary()
    print(dict)
}
```

--------------------------------

### Compile and Run Ryugraph C Code on macOS

Source: https://ryugraph.io/docs/get-started

Compilation and execution commands for Ryugraph C code on macOS systems. Uses DYLD_LIBRARY_PATH and LIBRARY_PATH environment variables to override library search paths, allowing the clang compiler and runtime to find the Ryugraph library in the current directory.

```bash
env DYLD_LIBRARY_PATH=. LIBRARY_PATH=. clang main.c -lryugraph
env DYLD_LIBRARY_PATH=. LIBRARY_PATH=. ./a.out
```

--------------------------------

### CMake Find and Link Ryugraph Library

Source: https://ryugraph.io/docs/get-started

Configures CMake to locate and link the Ryugraph library to a C++ target. Uses find_library to search in the lib directory and sets include paths for header files. This ensures the ryugraph-cpp executable has access to the Ryugraph library at compile and link time.

```cmake
find_library(RYUGRAPH_LIB ryugraph PATHS ${CMAKE_SOURCE_DIR}/lib REQUIRED)
target_link_libraries(ryugraph-cpp PRIVATE ${RYUGRAPH_LIB})
target_include_directories(ryugraph-cpp PRIVATE ${CMAKE_SOURCE_DIR}/include)
```

--------------------------------

### Load Data into Ryugraph Database Tables via COPY Command

Source: https://ryugraph.io/docs/get-started

Loads CSV data into Ryugraph database tables using the COPY command. Imports user, city, relationship, and location data from CSV files into the corresponding database tables. Demonstrates data ingestion pattern with proper result cleanup.

```c
// Load data.
ryugraph_connection_query(&conn, "COPY User FROM \"user.csv\"", &result);
ryugraph_query_result_destroy(&result);
ryugraph_connection_query(&conn, "COPY City FROM \"city.csv\"", &result);
ryugraph_query_result_destroy(&result);
ryugraph_connection_query(&conn, "COPY Follows FROM \"follows.csv\"", &result);
ryugraph_query_result_destroy(&result);
ryugraph_connection_query(&conn, "COPY LivesIn FROM \"lives-in.csv\"", &result);
ryugraph_query_result_destroy(&result);
```

--------------------------------

### Install Dependencies for Ryugraph and Data Handling

Source: https://ryugraph.io/docs/get-started/graph-algorithms

Installs necessary packages for Ryugraph, data manipulation with Polars and PyArrow, and scientific computing with NetworkX, NumPy, and SciPy. Ensure you have 'uv' installed to manage these dependencies.

```bash
uv init
uv add ryugraph polars pyarrow networkx numpy scipy

```

--------------------------------

### Query Ryugraph Database and Get Results as PyArrow Table (Python)

Source: https://ryugraph.io/docs/get-started

Executes a Cypher-like query on a Ryugraph database connection and retrieves the results formatted as a PyArrow Table. This is useful for data analysis and manipulation using the PyArrow library. Ensure the 'pyarrow' library is installed.

```python
import pyarrow

response = conn.execute(
    """
    MATCH (a:User)-[f:Follows]->(b:User)
    RETURN a.name, b.name, f.since;
    """
)
print(response.get_as_arrow())
```

--------------------------------

### Install an Extension in Ryu

Source: https://ryugraph.io/docs/extensions

This command installs an extension from a specified local extension server. Extensions must be installed before they can be loaded and used. Note that in v0.11.3 and later, some extensions are pre-installed.

```ryugraph-cypher
INSTALL <EXTENSION_NAME> FROM 'http://localhost:8080/';
```

--------------------------------

### Start Ryugraph CLI with In-Memory Database

Source: https://ryugraph.io/docs/client-apis/cli

Starts the Ryugraph CLI using an in-memory database. This mode does not persist data to disk.

```bash
ryugraph

Opened the database under in-memory mode.
Enter ":help" for usage hints.
ryugraph>
```

--------------------------------

### Query Results as Pandas DataFrame (Python)

Source: https://ryugraph.io/docs/get-started

This Python code demonstrates how to convert Ryugraph query results into a Pandas DataFrame. This requires the 'pandas' library to be installed (`pip install pandas`) and is useful for data analysis and manipulation.

```python
# pip install pandas
response = conn.execute(
    """
    MATCH (a:User)-[f:Follows]->(b:User)
    RETURN a.name, b.name, f.since;
    """
)
print(response.get_as_df())
```

--------------------------------

### Install asyncpg and Create PostgreSQL Database

Source: https://ryugraph.io/docs/extensions/attach/postgres

Installs the asyncpg library for Python and demonstrates creating a PostgreSQL table named 'person' and inserting sample data. This script connects to a local PostgreSQL instance, creates the table if it doesn't exist, inserts records, and then fetches and prints the table contents.

```bash
pip install asyncpg
```

```python
import asyncio
import asyncpg


async def main():
    conn = await asyncpg.connect('postgresql://postgres:testpassword@localhost:5432/postgres')
    # Create and insert data to a new table
    try:
        await conn.execute("CREATE TABLE IF NOT EXISTS person (name VARCHAR, age INTEGER);")
        await conn.execute("INSERT INTO person (name, age) VALUES ('Alice', 30)")
        await conn.execute("INSERT INTO person (name, age) VALUES ('Bob', 27)")
        await conn.execute("INSERT INTO person (name, age) VALUES ('Carol', 19)")
        await conn.execute("INSERT INTO person (name, age) VALUES ('Dan', 25)")
    except asyncpg.exceptions.DuplicateTableError:
        print(f"Table already exists, skipping creation and insertion...")
    # Check results
    print(await conn.fetch("SELECT * FROM person"))


asyncio.run(main())
```

--------------------------------

### Install ryugraph and yfiles-jupyter-graphs-for-ryugraph with uv

Source: https://ryugraph.io/docs/visualization/third-party-integrations/yfiles

This snippet demonstrates how to install the 'ryugraph' and 'yfiles-jupyter-graphs-for-ryugraph' packages using the 'uv' package manager. It initializes uv and adds the specified packages, assuming 'ryugraph' is a prerequisite.

```bash
# Install ryugraph as a pre-requisite
uv init
uv add ryugraph yfiles-jupyter-graphs-for-ryugraph

```

--------------------------------

### Query Results as Polars DataFrame (Python)

Source: https://ryugraph.io/docs/get-started

This Python code illustrates how to convert Ryugraph query results into a Polars DataFrame. This functionality is available if the 'polars' library is installed in your environment, offering an alternative for data processing.

```python
# Requires 'polars' to be installed
response = conn.execute(
    """
    MATCH (a:User)-[f:Follows]->(b:User)
    RETURN a.name, b.name, f.since;
    """
)
# Example usage with Polars would follow here, similar to the Pandas example.
```

--------------------------------

### Execute Cypher Query and Get Polars DataFrame

Source: https://ryugraph.io/docs/get-started

This snippet demonstrates executing a Cypher query against a graph database connection and retrieving the results directly as a Polars DataFrame. It shows the input query and the resulting DataFrame's schema and content.

```python
response = conn.execute(
    """
    MATCH (a:User)-[f:Follows]->(b:User)
    RETURN a.name, b.name, f.since;
    """
)
print(response.get_as_pl())
```

--------------------------------

### Install Ryugraph CLI on macOS via Homebrew

Source: https://ryugraph.io/docs/installation

Installs the Ryugraph CLI on macOS using Homebrew package manager. This is the simplest method for macOS users with Homebrew installed. After installation, the ryugraph command is immediately available in the terminal.

```shell
brew install ryugraph

ryugraph
```

--------------------------------

### Start Ryugraph CLI

Source: https://ryugraph.io/docs/tutorials/cypher

This command initiates the Ryugraph command line interface, allowing interactive querying and testing of Cypher statements against an in-memory database.

```bash
# Open an in-memory database
ryugraph
```

--------------------------------

### Initialize Ryugraph Database and Connection

Source: https://ryugraph.io/docs/get-started/graph-algorithms

Sets up a new Ryugraph database file and establishes a connection. It includes cleanup of previous database files to ensure a fresh start. The database is named 'example.ryugraph'.

```python
from pathlib import Path
import ryugraph

db_path = "example.ryugraph"


Path(db_path).unlink(missing_ok=True)
Path(db_path + ".wal").unlink(missing_ok=True)


db = ryugraph.Database(db_path)
conn = ryugraph.Connection(db)

```
Tokens:
Raw