Ladybug

https://docs.ladybugdb.com/
Admin
Ladybug is an embedded property graph database that supports a structured data model, Cypher query...
Tokens:139,698
Snippets:2,028
Trust Score:6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup Virtual Environment and Install Ladybug

Source: https://docs.ladybugdb.com/tutorials/python

Initializes a Python virtual environment and installs the required Ladybug package via pip.

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

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

### Install an Extension

Source: https://docs.ladybugdb.com/extensions

Install an official extension from the server. This only needs to be done once per extension.

```sql
INSTALL <EXTENSION_NAME>;
```

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

### Attach and query a DuckDB database

Source: https://docs.ladybugdb.com/extensions/adbc

Example workflow for installing the extension, attaching a local DuckDB file, and scanning a table.

```sql
INSTALL adbc;
LOAD adbc;
```

```sql
ATTACH 'games.duckdb' AS games_db (dbtype adbc, driver='duckdb', tables='games');
```

```sql
LOAD FROM games_db.games RETURN id, title, score ORDER BY id;
```

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

### Run PostgreSQL Server with Docker

Source: https://docs.ladybugdb.com/extensions/attach/postgres

Starts a PostgreSQL server locally using Docker. Ensure you have Docker installed and running.

```bash
docker run --rm --name lbug-postgres \
       -e POSTGRES_PASSWORD=testpassword \
       -p 5432:5432 \
       postgres:latest
```

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

### Install dependencies

Source: https://docs.ladybugdb.com/get-started/graph-algorithms

Install the required packages for Ladybug and graph analysis using uv.

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

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

### Start Ladybug CLI

Source: https://docs.ladybugdb.com/tutorials/cypher

Opens an in-memory database using the Ladybug CLI. Ensure Ladybug CLI is installed before running.

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

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

### Configure Icebug Disk with S3 Storage

Source: https://docs.ladybugdb.com/import/icebug

Example of creating node and relationship tables for icebug-disk format, specifying an S3 URI for storage. Ensure the `httpfs` extension is installed and configured.

```cypher
CREATE NODE TABLE city(id INT32, name STRING, population INT64, PRIMARY KEY(id))
  WITH (storage = 's3://my-bucket/mygraph/', format = 'icebug-disk');
CREATE REL TABLE livesin(FROM user TO city)
  WITH (storage = 's3://my-bucket/mygraph/', format = 'icebug-disk');
```

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

### Install asyncpg Python Library

Source: https://docs.ladybugdb.com/extensions/attach/postgres

Installs the asyncpg library, an asynchronous PostgreSQL client for Python, used for interacting with the database.

```bash
pip install asyncpg
```

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

### Set up Unity Catalog Server

Source: https://docs.ladybugdb.com/extensions/attach/unity

Clone the Unity Catalog repository and start the server. This is a prerequisite for using the extension.

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

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

### Execute Gradle Run Command

Source: https://docs.ladybugdb.com/get-started

Command to execute the Java example project.

```bash
gradle run
```

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

### Install Nightly Build for Node.js

Source: https://docs.ladybugdb.com/installation

Install the next version of the Ladybug Node.js package using npm.

```bash
npm i @ladybugdb/core@next
```

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

### Download CSV Data for Examples

Source: https://docs.ladybugdb.com/client-apis/python

Use these shell commands to prepare the local data directory and download the necessary CSV files for the Ladybug examples.

```bash
mkdir ./data/
curl -L -o ./data/city.csv https://raw.githubusercontent.com/LadybugDB/dataset/refs/heads/main/demo-db/csv/city.csv
curl -L -o ./data/user.csv https://raw.githubusercontent.com/LadybugDB/dataset/refs/heads/main/demo-db/csv/user.csv
curl -L -o ./data/follows.csv https://raw.githubusercontent.com/LadybugDB/dataset/refs/heads/main/demo-db/csv/follows.csv
curl -L -o ./data/lives-in.csv https://raw.githubusercontent.com/LadybugDB/dataset/refs/heads/main/demo-db/csv/lives-in.csv
```

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

### Download and Unzip Example Dataset

Source: https://docs.ladybugdb.com/extensions/attach/iceberg

This snippet shows how to download and extract an example Iceberg dataset for use with LadybugDB.

```bash
cd /tmp
wget https://lbugdb.github.io/data/iceberg-extension/iceberg_tables.zip
unzip iceberg_tables.zip
```

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

### Install and load the Ladybug algo extension

Source: https://docs.ladybugdb.com/get-started/graph-algorithms

Initializes the database connection and enables the algo extension.

```python
import ladybug as lb


db_path = "example.lbdb"


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


# Install and load the Ladybug algo extension
conn.execute("INSTALL algo; LOAD algo;")
```

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

### Install Node.js Dependencies

Source: https://docs.ladybugdb.com/developer-guide

Installs the required Node.js dependencies for building the Node.js bindings. Ensure Node.js version 14.15.0 or later is installed.

```bash
make nodejs-deps
```

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

### Install Python API Requirements

Source: https://docs.ladybugdb.com/developer-guide

Installs the necessary dependencies for the Python API. Ensure you have Python development headers installed.

```bash
make -C tools/python_api requirements
```

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

### Go Example Output

Source: https://docs.ladybugdb.com/get-started

Expected output format for the Go query.

```text
[Adam 2020 Karissa]
[Adam 2020 Zhang]
[Karissa 2021 Zhang]
[Zhang 2022 Noura]
```

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

### Install Nightly Build for Python

Source: https://docs.ladybugdb.com/installation

Install the pre-release version of the Ladybug Python package using uv pip.

```bash
uv pip install --pre ladybug
```

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

### Install Ladybug Library using CMake

Source: https://docs.ladybugdb.com/client-apis/c

Commands to build and install the Ladybug library using CMake. The dynamic library and header can be installed to a specified prefix, making them usable with other build systems.

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

```

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

### Install yFiles Jupyter Graphs for Ladybug with uv

Source: https://docs.ladybugdb.com/visualization/third-party-integrations/yfiles

Installs the ladybug and yfiles-jupyter-graphs-for-kuzu packages using uv. Ensure lbug is installed as a pre-requisite.

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

```

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

### Start on-disk database CLI

Source: https://docs.ladybugdb.com/client-apis/cli

Opens a database in read-write mode at the specified path, creating it if it does not exist.

```bash
$ lbug example.lbdb
```

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

### Create Node and Relationship Tables

Source: https://docs.ladybugdb.com/import/copy-from-subquery

Initial schema setup for Person, Product, and HasReward tables.

```sql
CREATE NODE TABLE Person(name STRING PRIMARY KEY, num_purchases INT64)
CREATE NODE TABLE Product(name STRING PRIMARY KEY, price DOUBLE)
CREATE REL TABLE HasReward(FROM Person TO Product);
```

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

### Attach Example PostgreSQL Database

Source: https://docs.ladybugdb.com/extensions/attach/postgres

Example of attaching a PostgreSQL database named 'university' to Ladybug with the alias 'uw'.

```sql
ATTACH
    'dbname=university user=postgres host=localhost password=testpassword port=5432' AS uw
    (dbtype postgres);
```

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

### Install Delta Lake and Pandas

Source: https://docs.ladybugdb.com/extensions/attach/delta

Install the necessary Python packages for working with Delta Lake and Pandas.

```bash
pip install deltalake pandas

```

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

### Install Build Dependencies on Ubuntu

Source: https://docs.ladybugdb.com/developer-guide

Installs necessary build tools including CMake, GCC, Python, Ninja, and ccache on Ubuntu.

```bash
apt update
apt install -y build-essential cmake gcc g++ python3 ninja-build ccache
```

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

### Link Ladybug from Source with CMake (FetchContent)

Source: https://docs.ladybugdb.com/client-apis/c

Example using FetchContent to download and build Ladybug as a dependency within a CMake project. It links the library statically or dynamically to an example executable, configurable via the EXAMPLE_SHARED option.

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

```

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

### Install Build Dependencies on Windows

Source: https://docs.ladybugdb.com/developer-guide

Installs Python, Make, and Ninja using Chocolatey package manager on Windows.

```powershell
choco install -y python3 make ninja
```

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

### Rust Example Output

Source: https://docs.ladybugdb.com/get-started

Expected output format for the Rust query.

```text
Adam, 2020, Karissa
Adam, 2020, Zhang
Karissa, 2021, Zhang
Zhang, 2022, Noura
```

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

### Install ADBC drivers

Source: https://docs.ladybugdb.com/extensions/adbc

Use the dbc tool to install necessary ADBC driver libraries for specific database backends.

```bash
# Install dbc tool
uv tool install dbc


# PostgreSQL
dbc install postgresql


# DuckDB
dbc install duckdb


# SQLite
dbc install sqlite


# Snowflake
dbc install snowflake
```

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

### Expected Swift Output

Source: https://docs.ladybugdb.com/get-started

The console output after running the Swift example.

```text

["b.name": Optional("Karissa"), "e.since": Optional(2020), "a.name": Optional("Adam")]
["e.since": Optional(2020), "a.name": Optional("Adam"), "b.name": Optional("Zhang")]
["b.name": Optional("Zhang"), "e.since": Optional(2021), "a.name": Optional("Karissa")]
["e.since": Optional(2022), "a.name": Optional("Zhang"), "b.name": Optional("Noura")]

```

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

### Install and Load HTTPFS Extension

Source: https://docs.ladybugdb.com/import/icebug

Install and load the `httpfs` extension in Ladybug, which is required for accessing remote storage like S3. This also includes setting up S3 credentials.

```sql
INSTALL httpfs;
LOAD httpfs;
CALL s3_credential(
  key_id='YOUR_KEY_ID',
  secret='YOUR_SECRET',
  region='us-east-1'
);
```

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

### Example: Create a vector index on a table

Source: https://docs.ladybugdb.com/extensions/vector

Practical example of creating a vector index on the 'title_embedding' column of the 'Book' table using the 'l2' metric.

```sql
CALL CREATE_VECTOR_INDEX(
    'Book',
    'book_title_index',
    'title_embedding',
    metric := 'l2'
);
```

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

### Install Build Dependencies on AlmaLinux

Source: https://docs.ladybugdb.com/developer-guide

Installs necessary build tools including CMake, GCC, Python, Ninja, and ccache on AlmaLinux.

```bash
dnf update
dnf install -y cmake gcc gcc-c++ python3 ninja-build ccache
```

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

### Less Than Operator Example

Source: https://docs.ladybugdb.com/cypher/expressions/comparison-operators

Demonstrates the use of the less than operator (<).

```text
2 < 3
```

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

### Install Ladybug Python Client with Nix

Source: https://docs.ladybugdb.com/installation

Installs the Ladybug Python client library using Nix. This command creates a development shell with Python and the Ladybug package available.

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

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

### Query Output Example

Source: https://docs.ladybugdb.com/get-started/prepared-statements

Expected output format after running the database query.

```text

n.name | n.age | n.embedding
Alice | 25 | [10, 20, 30]
Bob | 30 | [40, 50.1, 60]


```

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

### Java Project Configuration

Source: https://docs.ladybugdb.com/get-started

Example Gradle build configuration for a Java application using the LadybugDB client.

```groovy
plugins {
    id 'java'
    id 'application'
}
application {
    mainClassName = "Main"
}
repositories {
    mavenCentral()
}
dependencies {
    implementation 'com.ladybugdb:lbug:0.11.0'
}
```

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

### Running a Specific Test File with e2e_test

Source: https://docs.ladybugdb.com/developer-guide/testing-framework

Example of running all tests from a specific .test file using the e2e_test binary.

```bash
# Run all tests from test/test_files/long_string_pk.test file
$ ./e2e_test long_string_pk/long_string_pk.test
```

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

### Type Of Function Example

Source: https://docs.ladybugdb.com/cypher/expressions/utility-functions

Use the typeof function to get the name of the data type of an argument.

```cypher
typeof(true)
```

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

### Initialize and Query Database in Go

Source: https://docs.ladybugdb.com/get-started

Demonstrates database configuration, schema setup, and query execution using the go-ladybug driver.

```go
package main


import (
    "fmt"


    "github.com/LadybugDB/go-ladybug"
)


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


    conn, err := lb.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)
    }
```

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

### Initialize and Query Database in C++

Source: https://docs.ladybugdb.com/get-started

Setup a C++ database connection, run schema creation, load data, and iterate through query results.

```cpp

#include <iostream>


#include "include/lb.hpp"


using namespace lbug::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.lbdb
    remove("example.lbdb");
    remove("example.lb.wal");


    // Create an empty on-disk database and connect to it
    SystemConfig systemConfig;
    auto database = make_unique<Database>("example.lbdb", 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;
}

```

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

### Install Build Dependencies on Arch Linux

Source: https://docs.ladybugdb.com/developer-guide

Installs necessary build tools including base-devel, CMake, GCC, Python, Ninja, and ccache on Arch Linux.

```bash
pacman -Syu
pacman -S --needed base-devel cmake gcc python ninja ccache
```

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

### ResultSet Example

Source: https://docs.ladybugdb.com/developer-guide/database-internal/vector

Demonstrates a ResultSet as a Cartesian product of DataChunks, forming a comprehensive dataset.

```text
Result set
    Data chunk
        Value vector: [1, 2, 3]
        Value vector: [a, b, c]
    Data Chunk
        Value vector: [10, 11]


Data being represented:
    [(1,a,10), (2,b,10), (3,c,10), (1,a,11), (2,b,11), (3,c,11)]
```

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

### Download Example Data

Source: https://docs.ladybugdb.com/tutorials/example-database

Use curl to download the zipped tutorial data. Unzip the downloaded file to your current working directory.

```bash
curl -o tutorial_data.zip https://huggingface.co/datasets/ladybugdb/python-tutorial/resolve/main/tutorial_data.zip
unzip tutorial_data.zip
```

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

### Less Than or Equal To Operator Example

Source: https://docs.ladybugdb.com/cypher/expressions/comparison-operators

Demonstrates the use of the less than or equal to operator (<=).

```text
3 <= 3
```

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

### Install Ladybug Wasm Core

Source: https://docs.ladybugdb.com/client-apis/wasm

Install the Ladybug Wasm core package using npm. This is the first step to using Ladybug's WebAssembly capabilities.

```bash
npm i @ladybugdb/wasm-core
```

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

### Running All Tests in a Directory with e2e_test

Source: https://docs.ladybugdb.com/developer-guide/testing-framework

Example of running all tests within a specified directory using the e2e_test binary.

```bash
# Run all tests inside test/test_files/copy
$ ./e2e_test copy
```

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

### Initialize Swift Project

Source: https://docs.ladybugdb.com/get-started

Commands to create a new Swift executable project.

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

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

### Create Project Directory and Files

Source: https://docs.ladybugdb.com/tutorials/python

Sets up the source directory and creates the necessary Python script files for database creation and querying.

```bash
mkdir src
touch src/create_db.py
touch src/main.py
```

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

### Install Ladybug for Windows (x86_64)

Source: https://docs.ladybugdb.com/installation

Download the Ladybug binary for x86_64 Windows systems.

```bash
curl -L -O https://github.com/LadybugDB/ladybug/releases/download/v0.11.0/liblbug-windows-x86_64.zip
```

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

### Sample Data Format

Source: https://docs.ladybugdb.com/get-started

Example of the expected CSV data format used by the application.

```text
Adam | 2020 | Karissa
Adam | 2020 | Zhang
Karissa | 2021 | Zhang
Zhang | 2022 | Noura
```

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

### Initialize and Query Database in Java

Source: https://docs.ladybugdb.com/get-started

Demonstrates creating a database, defining schema, loading CSV data, and executing a Cypher query.

```java
import com.ladybugdb.*;


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.lbdb");
        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 yFiles Jupyter Graphs for Ladybug with pip

Source: https://docs.ladybugdb.com/visualization/third-party-integrations/yfiles

Installs the ladybug and yfiles-jupyter-graphs-for-kuzu packages using pip. Ensure lbug is installed as a pre-requisite.

```bash
# Install lbug as a pre-requisite
pip install ladybug yfiles-jupyter-graphs-for-kuzu

```

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

### DataChunk Example

Source: https://docs.ladybugdb.com/developer-guide/database-internal/vector

Illustrates a DataChunk as a collection of ValueVectors representing a structured dataset.

```text
Data chunk
    Value vector: [1, 2, 3]
    Value vector: [a, b, c]



Data being represented:
[(1,a), (2,b), (3,c)]
```

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

### Initialize Database and Execute Queries in Python

Source: https://docs.ladybugdb.com/get-started

Create an on-disk database, define the schema, import data from CSVs, and run a Cypher query.

```python
import ladybug as lb


def main():
    # Create an empty on-disk database and connect to it
    db = lb.Database("example.lbdb")
    conn = lb.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()
```

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

### Run Database Creation Command

Source: https://docs.ladybugdb.com/tutorials/rust

Executes the binary and displays the resulting table metadata output.

```bash

$ cargo run --bin create_db
id|name|type|database name|comment
0|User|NODE|local(lbug)|
1|Post|NODE|local(lbug)|
3|FOLLOWS|REL|local(lbug)|
5|POSTS|REL|local(lbug)|
7|LIKES|REL|local(lbug)|
```

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

### Install Ladybug CLI with Homebrew

Source: https://docs.ladybugdb.com/installation

Installs the Ladybug CLI using the Homebrew package manager on macOS. Ensure Homebrew is installed before running this command.

```shell
brew install ladybug
```

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

### C++ Prepared Statements Implementation

Source: https://docs.ladybugdb.com/get-started/prepared-statements

Demonstrates setting up a database, creating a schema, and executing queries using prepared statements with parameter binding.

```cpp

#include <cassert>
#include <iostream>
#include <ranges>


#include "lbug.hpp"


using namespace lbug::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;
}


unique_ptr<QueryResult>
runPreparedQuery(const string_view &query,
                 std::unordered_map<std::string, std::unique_ptr<lbug::common::Value>> inputParams,
                 const unique_ptr<Connection> &connection) {
    auto prepared_stmt = connection->prepare(query);
    if (!prepared_stmt->isSuccess()) {
        throw std::runtime_error(prepared_stmt->getErrorMessage());
    }


    auto results = connection->executeWithParams(prepared_stmt.get(), std::move(inputParams));
    if (!results->isSuccess()) {
        throw std::runtime_error(results->getErrorMessage());
    }


    return results;
}


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


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


    // Create the schema.
    runQuery("CREATE NODE TABLE N(id SERIAL PRIMARY KEY, name STRING, age INT64, embedding FLOAT[])", connection);


    // Create a node.
    runQuery("CREATE (:N {name: 'Alice', embedding: [10.0, 20.0, 30.0], age: 25});", connection);


    std::unordered_map<std::string, unique_ptr<lbug::common::Value>> args;


    // `name` parameter.
    args.emplace("name", make_unique<lbug::common::Value>("Bob"));


    // `age` parameter.
    uint64_t age = 30;
    args.emplace("age", make_unique<lbug::common::Value>(age));


    // `embedding` parameter.
    auto type = lbug::common::LogicalType::LIST(lbug::common::LogicalType::FLOAT());
    vector<unique_ptr<lbug::common::Value>> data;
    data.push_back(make_unique<lbug::common::Value>((float)40.0));
    data.push_back(make_unique<lbug::common::Value>((float)50.1));
    data.push_back(make_unique<lbug::common::Value>((float)60.0));
    args.emplace("embedding", make_unique<lbug::common::Value>(std::move(type), std::move(data)));


    // Create a node using parameters.
    runPreparedQuery("CREATE (:N {name: $name, age: $age, embedding: $embedding});", std::move(args), connection);


    // Execute a match query.
    auto result = runQuery("MATCH (n) RETURN n.name, n.age, n.embedding;", connection);


    // Print the column names.
    auto columns = result->getColumnNames();
    for (auto i = 0u; i < columns.size(); ++i) {
        if (i != 0) {
            cout << " | ";
        }
        cout << columns[i];
    }
    cout << "\n";


    // Print the rows.
    while (result->hasNext()) {
        auto row = result->getNext();


        // Print `name`.
        auto value_name = row->getValue(0);
        KU_ASSERT_UNCONDITIONAL(value_name->getDataType().getLogicalTypeID() == lbug::common::LogicalTypeID::STRING);
        cout << value_name->getValue<string>() << " | ";


        // Print `age`.
        auto value_int64 = row->getValue(1);
        KU_ASSERT_UNCONDITIONAL(value_int64->getDataType().getLogicalTypeID() == lbug::common::LogicalTypeID::INT64);
        cout << value_int64->getValue<int64_t>() << " | ";


        // Print `embedding`.
        auto value_embedding = row->getValue(2);
        KU_ASSERT_UNCONDITIONAL(value_embedding->getDataType().getLogicalTypeID() == lbug::common::LogicalTypeID::LIST);
        auto length = value_embedding->getChildrenSize();
        vector<float> embedding;
        for (auto i = 0u; i < length; ++i) {
            auto element = lbug::common::NestedVal::getChildVal(value_embedding, i);
            KU_ASSERT_UNCONDITIONAL(element->getDataType().getLogicalTypeID() == lbug::common::LogicalTypeID::FLOAT);
            embedding.push_back(element->getValue<float>());
        }
        auto join = [](const std::vector<float>& vec, const std::string& sep) {
            std::ostringstream oss;
            for (size_t i = 0; i < vec.size(); i++) {
                if (i > 0) oss << sep;
                oss << vec[i];
            }
            return oss.str();
        };
        cout << "[" << join(embedding, ", ") << "]\n";
    }
    return 0;
}


```

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

### Install Ladybug CLI with Shell Script

Source: https://docs.ladybugdb.com/installation

Installs the Ladybug CLI using a curl command to download and execute an installation script. This is a common method for Linux and macOS.

```shell
curl -s https://install.ladybugdb.com | bash
```

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

### Install Ladybug Python Client with pip

Source: https://docs.ladybugdb.com/installation

Installs the Ladybug Python client library using pip, the standard Python package installer. This command is compatible with Linux, macOS, and Windows.

```shell
pip install ladybug
```

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

### Initialize and Query Database in Rust

Source: https://docs.ladybugdb.com/get-started

Demonstrates database connection, schema creation, data loading, and query execution using the lbug crate.

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


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


    // Create the 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 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!("{}, {}, {}", row[0], row[1], row[2]);
    }
    Ok(())
}
```

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

### Install Ladybug for Linux (aarch64)

Source: https://docs.ladybugdb.com/installation

Download and extract the Ladybug binary for aarch64 Linux systems.

```bash
curl -L -O https://github.com/LadybugDB/ladybug/releases/download/v0.11.0/liblbug-linux-aarch64.tar.gz

tar xzf liblbug-*.tar.gz
```

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

### Building Extension Tests

Source: https://docs.ladybugdb.com/developer-guide/testing-framework

Command to build extension tests, which may require installing DuckDB.

```bash
# Build extension tests. You would need to install DuckDB to build the extension tests. See https://duckdb.org/install/
$ make extension-test-build
```

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

### Load an Official Extension

Source: https://docs.ladybugdb.com/extensions

Load an installed official extension into the current session to make its functionality available.

```sql
load json;
```

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

### Build and Run Swift Project

Source: https://docs.ladybugdb.com/get-started

Commands to compile the Swift project and execute the resulting binary.

```bash

swift build -c release

```

```bash

cp ./.build/arm64-apple-macosx/release/lbug-swift-example .

```

```bash

./lbug-swift-example

```

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

### Update an Installed Extension

Source: https://docs.ladybugdb.com/extensions

Re-download an extension if it is not working properly or if you need to ensure you have the latest version.

```sql
UPDATE <EXTENSION_NAME>;
```

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

### JSON Data Example

Source: https://docs.ladybugdb.com/import/copy-from-json

This is an example of a JSON file structure that can be imported into a Ladybug node table.

```json
[
    {
        "p_id": "p1",
        "name": "Gregory",
        "info": {
            "height": 1.81,
            "weight": 75.5,
            "age": 35,
            "insurance_provider": [
                {
                    "type": "health",
                    "name": "Blue Cross Blue Shield",
                    "policy_number": "1536425345"
                }
            ]
        }
    },
    {
        "p_id": "p2",
        "name": "Alicia",
        "info": {
            "height": 1.65,
            "weight": 60.1,
            "age": 28,
            "insurance_provider": [
                {
                    "type": "health",
                    "name": "Aetna",
                    "policy_number": "9876543210"
                }
            ]
        }
    },
    {
        "p_id": "p3",
        "name": "Rebecca"
    }
]
```

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

### Download and Extract Tutorial Data

Source: https://docs.ladybugdb.com/tutorials/rust

Fetch the social network dataset and prepare it for import.

```bash
curl -o tutorial_data.zip https://huggingface.co/datasets/ladybugdb/python-tutorial/resolve/main/tutorial_data.zip
unzip tutorial_data.zip
rm tutorial_data.zip
```

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

### GTest Test Registration Example

Source: https://docs.ladybugdb.com/developer-guide/testing-framework

Illustrates how a basic test case from a .test file is registered as a GTest test.

```cpp
TEST_F(basic, e2e_test_BasicTest) { ... }
```

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

### Get Month Name from Date

Source: https://docs.ladybugdb.com/cypher/expressions/date-functions

Use `monthname` to get the English name of the month for a given date.

```cypher
monthname(DATE('2022-11-07'))
```

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

### Display CLI help menu

Source: https://docs.ladybugdb.com/client-apis/cli

Lists all available command line flags and options for the lbug executable.

```bash
$ lbug -h
```

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

### Initialize and Query Database in Swift

Source: https://docs.ladybugdb.com/get-started

Create a database connection, define schema, load CSV data, and execute a Cypher query.

```swift

import Ladybug


// Create an empty on-disk database and connect to it
let db = try! Database("example.lbdb")
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)
}

```

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

### Start in-memory database CLI

Source: https://docs.ladybugdb.com/client-apis/cli

Launches the CLI shell using an in-memory database by omitting the path argument.

```bash
lbug
```

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

### Load from JSON file

Source: https://docs.ladybugdb.com/cypher/query-clauses/load-from

Scan a JSON file directly using the LOAD FROM clause after installing the JSON extension.

```sql
INSTALL json;
LOAD json;


// Scan the JSON file
LOAD FROM "user.json" RETURN *;
```

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

### Build and Run C++ Project

Source: https://docs.ladybugdb.com/get-started

Commands to generate build files, compile the project, and execute the resulting binary.

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

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

### Initialize Ladybug database connection

Source: https://docs.ladybugdb.com/tutorials/python

Sets up the database file and establishes a connection for subsequent operations.

```python

def main() -> None:
    db = lb.Database("social_network.lbdb")
    conn = lb.Connection(db)


    # Rest of the code goes here


if __name__ == "__main__":
    main()

```

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

### Get Day Name from Date

Source: https://docs.ladybugdb.com/cypher/expressions/date-functions

Use `dayname` to get the English name of the day of the week for a given date.

```cypher
dayname(DATE('2022-11-07'))
```

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

### Create Database Import Target

Source: https://docs.ladybugdb.com/tutorials/rust

Set up a separate binary target for the one-time database creation process.

```bash
mkdir src/bin
cp src/main.rs src/bin/create_db.rs
```

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

### Initialize and Query LadybugDB in C

Source: https://docs.ladybugdb.com/get-started

Demonstrates the full lifecycle of a LadybugDB database including initialization, schema creation, data loading, and query execution.

```c

#include <stdio.h>


#include "include/lb.h"


int main()
{
    // Create an empty on-disk database and connect to it
    lbug_database db;
    lbug_database_init("example.lbdb", lbug_default_system_config(), &db);


    // Connect to the database.
    lbug_connection conn;
    lbug_connection_init(&db, &conn);


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


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


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


    // Output query result.
    lbug_flat_tuple tuple;
    lbug_value value;
    while (lbug_query_result_has_next(&result))
    {
        lbug_query_result_get_next(&result, &tuple);


        lbug_flat_tuple_get_value(&tuple, 0, &value);
        char *name = NULL;
        lbug_value_get_string(&value, &name);
        lbug_value_destroy(&value);


        lbug_flat_tuple_get_value(&tuple, 1, &value);
        int64_t since = 0;
        lbug_value_get_int64(&value, &since);
        lbug_value_destroy(&value);


        lbug_flat_tuple_get_value(&tuple, 2, &value);
        char *name2 = NULL;
        lbug_value_get_string(&value, &name2);
        lbug_value_destroy(&value);




        printf("%s follows %s since %lld \n", name, name2, since);
        free(name);
        free(name2);
    }
    lbug_value_destroy(&value);
    lbug_flat_tuple_destroy(&tuple);
    lbug_query_result_destroy(&result);
    lbug_connection_destroy(&conn);
    lbug_database_destroy(&db);
    return 0;
}
```

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

### Create Embedding with OpenAI

Source: https://docs.ladybugdb.com/extensions/llm

Example of creating an embedding using OpenAI. No additional provider-specific arguments are shown as required in this basic example.

```cypher
RETURN CREATE_EMBEDDING( "Hello world", "openai", "text-embedding-3-small");
```

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

### Create Embedding with Ollama

Source: https://docs.ladybugdb.com/extensions/llm

Example of creating an embedding using Ollama. No additional provider-specific arguments are shown as required in this basic example.

```cypher
RETURN CREATE_EMBEDDING("Hello world", "ollama", "nomic-embed-text");
```

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

### Install Ladybug Python Client with uv

Source: https://docs.ladybugdb.com/installation

Initializes a project with uv and adds the Ladybug Python client library. This is a modern approach for managing Python dependencies.

```shell
uv init
uv add ladybug
```

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

### Install Build Dependencies on macOS

Source: https://docs.ladybugdb.com/developer-guide

Installs Xcode command-line tools and Homebrew packages including CMake, Python, Ninja, and ccache on macOS.

```bash
xcode-select --install
brew install cmake python ninja ccache
```

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

### Automatic Test Result Rewriting (Setup)

Source: https://docs.ladybugdb.com/developer-guide/testing-framework

Illustrates the initial state of a test file before automatic test result rewriting is applied.

```bash
$ cat test/test_files/demo.test
-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

```

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

### Getting List Length in Cypher

Source: https://docs.ladybugdb.com/cypher/expressions/list-functions

Demonstrates using the `size()` function to get the number of elements in a list. This is useful for iteration or conditional logic.

```cypher
RETURN size([1, 2, 3]) // Returns 3
```

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

### Run Cargo Targets

Source: https://docs.ladybugdb.com/tutorials/rust

Execute the main application and the database creation binary.

```bash
$ cargo run --bin lbug_social_network
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 3m 18s
     Running `target/debug/lbug_social_network`


$ cargo run --bin create_db
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.14s
     Running `target/debug/create_db`
```

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

### Launch Ladybug Explorer with Existing Database

Source: https://docs.ladybugdb.com/visualization/lbug-explorer

Use this command to launch Ladybug Explorer and connect to an existing Ladybug database file. Mount the local directory containing the database to `/database` and specify the database file name using `LBUG_FILE`. Changes in the UI will persist to this file.

```bash
docker run -p 8000:8000 \
           -v {path to the directory containing the database file}:/database \
           -e LBUG_FILE={database file name} \
           --rm ghcr.io/ladybugdb/explorer:latest
```

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

### Set Default Database and Load Data

Source: https://docs.ladybugdb.com/extensions/attach/postgres

Attach a PostgreSQL database with an alias and set it as the default to simplify queries. This example loads all data from the 'person' table.

```sql
ATTACH 'university' AS uw (dbtype postgres);
USE uw;
LOAD FROM person
RETURN *;
```

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

### Create Embedding with Voyage AI

Source: https://docs.ladybugdb.com/extensions/llm

Example of creating an embedding using Voyage AI. No additional provider-specific arguments are shown as required in this basic example.

```cypher
RETURN CREATE_EMBEDDING( "Hello world", "voyageai", "voyage-3-large");
```

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

### Initialize database and import CSV data

Source: https://docs.ladybugdb.com/tutorials/rust

Defines the database schema for Users, Posts, and relationships, then imports data from CSV files.

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


fn main() -> Result<(), Error> {
    let db = Database::new("social_network.lbdb", SystemConfig::default())?;
    let conn = Connection::new(&db)?;


    conn.query(
        "CREATE NODE TABLE User(
            user_id INT64 PRIMARY KEY,
            username STRING,
            account_creation_date DATE
        )",
    )?;
    conn.query(
        "CREATE NODE TABLE Post(
            post_id INT64 PRIMARY KEY,
            post_date DATE,
            like_count INT64,
            retweet_count INT64
        )",
    )?;
    conn.query(
        "CREATE REL TABLE FOLLOWS(
            FROM User TO User
        )",
    )?;
    conn.query(
        "CREATE REL TABLE POSTS(
            FROM User TO Post
        )",
    )?;
    conn.query(
        "CREATE REL TABLE LIKES(
            FROM User TO Post
        )",
    )?;


    conn.query("COPY User FROM './tutorial_data/node/user.csv'")?;
    conn.query("COPY Post FROM './tutorial_data/node/post.csv'")?;
    conn.query("COPY FOLLOWS FROM './tutorial_data/relation/FOLLOWS.csv'")?;
    conn.query("COPY POSTS FROM './tutorial_data/relation/POSTS.csv'")?;
    conn.query("COPY LIKES FROM './tutorial_data/relation/LIKES.csv'")?;


    let result = conn.query("CALL SHOW_TABLES() RETURN *")?;
    println!("{}", result);


    Ok(())
}
```

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

### Create Embedding with Google Gemini

Source: https://docs.ladybugdb.com/extensions/llm

Example of creating an embedding using Google Gemini. No additional provider-specific arguments are shown as required in this basic example.

```cypher
RETURN CREATE_EMBEDDING("Hello world", "google-gemini", "gemini-embedding-exp-03-07");
```

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

### Declarative Nix Installation

Source: https://docs.ladybugdb.com/installation

Configures Ladybug installation declaratively using Nix. This snippet shows how to add Ladybug to system packages for NixOS or Home Manager.

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

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

### Start Ladybug with Icebug Disk Schema

Source: https://docs.ladybugdb.com/import/icebug

Launch Ladybug and specify the generated schema file using the `-i` flag to load the icebug-disk graph.

```bash
lbug -i csr_graph/schema.cypher
```

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

### Initialize LadybugDB Connection

Source: https://docs.ladybugdb.com/tutorials/rust

Sets up the database connection and main function structure for executing queries.

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


fn main() -> Result<(), Error> {
    let db = Database::new("social_network.lbdb", SystemConfig::default())?;
    let conn = Connection::new(&db)?;


    // Rest of the code goes here.


    Ok(())
}
```
Tokens:
Raw