The open source graph database built for super large-scale graphs with milliseconds of latency.
Optimized the performance of k-hop and GO statement, and fixed some bugs.
Proudly open source
NebulaGraph adopts the Apache 2.0 license, one of the most permissive free software licenses in the world. Free as in freedom, because, under the Apache 2.0 license, you can use, copy, modify and redistribute NebulaGraph, even for commercial purposes, all without asking for permission.
We believe that great open source projects are not built in isolation, but rather by a community of contributors. We welcome contributions to Nebula Graph from anyone regardless of skill level or background in software development. If you have an idea for a feature you would like to see added, or you have identified a bug that needs fixing, please don't hesitate to submit an issue to our Github repository.
NebulaGraph comes with a wide range of data visualization tools, including NebulaGraph Dashboard, NebulaGraph Explorer, and NebulaGraph Studio. Using tools like NebulaGraph Algorithm and NebulaGraph Analytics, you can easily integrate NebulaGraph with other open source big data frameworks like Spark GraphX, Flink, and Tencent Plato, to enhance your graph computing ability.
The graph database following the cloud-native way
NebulaGraph leverages the powerful storage engine RocksDB to provide low-latency read and write and high throughput. It uses a state-of-the-art design that delivers highly concurrent access, fast graph traversals, and efficient use of memory. NebulaGraph is the only open source graph database that can store and process graphs with trillions of edges and vertices.
Learn moreNebulaGraph’s nGQL query language is gradually compatible with openCypher. This enables openCypher users to easily get started with NebulaGraph with a zero learning curve.
Learn moreWith a shared-nothing distributed architecture, NebulaGraph offers linear scalability, meaning that you can add more nodes or services to the cluster without affecting performance. It also means that if you want to horizontally scale out NebulaGraph, you don’t need to change the configuration of the existing nodes. As long as the network bandwidth is sufficient, you can add more nodes without changing anything else.
Learn moreWith horizontal scalability and a snapshot feature, NebulaGraph guarantees high availability even in case of failures. The snapshot feature allows users to take snapshots of a NebulaGraph instance at any point in time so that they can use them to restore data at that specific time. If a disaster occurs, NebulaGraph can be recovered from snapshots without data loss. When an instance fails, NebulaGraph will first remove this instance from the cluster and create a new one based on the snapshot to replace this failed instance. This process is fully automatic and transparent to clients.
Learn moreNebulaGraph is mature, stable, and production-ready. NebulaGraph has been widely used in production by large internet companies including Meituan, Tencent, WeBank, Boss Zhipin, and Zhihu. These companies are using NebulaGraph in their production environments for real-world applications like knowledge graph, recommendation systems, and fraud detection.
Learn moreArchitecture
Welcome to NebulaGraph Community
#include <atomic>
#include <chrono>
#include <thread>
#include <nebula/client/Config.h>
#include <nebula/client/ConnectionPool.h>
#include <common/Init.h>
int main(int argc, char* argv[]) {
nebula::init(&argc, &argv);
auto address = "127.0.0.1:9669";
if (argc == 2) {
address = argv[1];
}
std::cout << "Current address: " << address << std::endl;
nebula::ConnectionPool pool;
pool.init({address}, nebula::Config{});
auto session = pool.getSession("root", "nebula");
if (!session.valid()) {
return -1;
}
auto result = session.execute("SHOW HOSTS");
if (result.errorCode != nebula::ErrorCode::SUCCEEDED) {
std::cout << "Exit with error code: " << static_cast<int>(result.errorCode) << std::endl;
return static_cast<int>(result.errorCode);
}
std::cout << *result.data;
std::atomic_bool complete{false};
session.asyncExecute("SHOW HOSTS", [&complete](nebula::ExecutionResponse&& cbResult) {
if (cbResult.errorCode != nebula::ErrorCode::SUCCEEDED) {
std::cout << "Exit with error code: " << static_cast<int>(cbResult.errorCode)
<< std::endl;
std::exit(static_cast<int>(cbResult.errorCode));
}
std::cout << *cbResult.data;
complete.store(true);
});
while (!complete.load()) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
session.release();
return 0;
}
import (
"fmt"
nebula "github.com/vesoft-inc/nebula-go/v3"
)
const (
address = "127.0.0.1"
// The default port of NebulaGraph 2.x is 9669.
// 3699 is only for testing.
port = 3699
username = "root"
password = "nebula"
)
// Initialize logger
var log = nebula.DefaultLogger{}
func main() {
hostAddress := nebula.HostAddress{Host: address, Port: port}
hostList := []nebula.HostAddress{hostAddress}
// Create configs for connection pool using default values
testPoolConfig := nebula.GetDefaultConf()
// Initialize connection pool
pool, err := nebula.NewConnectionPool(hostList, testPoolConfig, log)
if err != nil {
log.Fatal(fmt.Sprintf("Fail to initialize the connection pool, host: %s, port: %d, %s", address, port, err.Error()))
}
// Close all connections in the pool
defer pool.Close()
// Create session
session, err := pool.GetSession(username, password)
if err != nil {
log.Fatal(fmt.Sprintf("Fail to create a new session from connection pool, username: %s, password: %s, %s",
username, password, err.Error()))
}
// Release session and return connection back to connection pool
defer session.Release()
checkResultSet := func(prefix string, res *nebula.ResultSet) {
if !res.IsSucceed() {
log.Fatal(fmt.Sprintf("%s, ErrorCode: %v, ErrorMsg: %s", prefix, res.GetErrorCode(), res.GetErrorMsg()))
}
}
{
// Prepare the query
createSchema := "CREATE SPACE IF NOT EXISTS basic_example_space(vid_type=FIXED_STRING(20)); " +
"USE basic_example_space;" +
"CREATE TAG IF NOT EXISTS person(name string, age int);" +
"CREATE EDGE IF NOT EXISTS like(likeness double)"
// Excute a query
resultSet, err := session.Execute(createSchema)
if err != nil {
fmt.Print(err.Error())
return
}
checkResultSet(createSchema, resultSet)
}
// Drop space
{
query := "DROP SPACE IF EXISTS basic_example_space"
// Send query
resultSet, err := session.Execute(query)
if err != nil {
fmt.Print(err.Error())
return
}
checkResultSet(query, resultSet)
}
fmt.Print("
")
log.Info("Nebula Go Client Basic Example Finished")
}
NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig();
nebulaPoolConfig.setMaxConnSize(10);
List<HostAddress> addresses = Arrays.asList(new HostAddress("127.0.0.1", 9669),
new HostAddress("127.0.0.1", 9670));
NebulaPool pool = new NebulaPool();
pool.init(addresses, nebulaPoolConfig);
Session session = pool.getSession("root", "nebula", false);
session.execute("SHOW HOSTS;");
session.release();
pool.close();
from nebula3.gclient.net import ConnectionPool
from nebula3.Config import Config
# define a config
config = Config()
config.max_connection_pool_size = 10
# init connection pool
connection_pool = ConnectionPool()
# if the given servers are ok, return true, else return false
ok = connection_pool.init([('127.0.0.1', 9669)], config)
# option 1 control the connection release yourself
# get session from the pool
session = connection_pool.get_session('root', 'nebula')
# select space
session.execute('USE nba')
# show tags
result = session.execute('SHOW TAGS')
print(result)
# release session
session.release()
# option 2 with session_context, session will be released automatically
with connection_pool.session_context('root', 'nebula') as session:
session.execute('USE nba')
result = session.execute('SHOW TAGS')
print(result)
# close the pool
connection_pool.close()
// ESM
import { createClient } from '@nebula-contrib/nebula-nodejs'
// CommonJS
// const { createClient } = require('@nebula-contrib/nebula-nodejs')
// Connection Options
const options = {
servers: ['ip-1:port','ip-2:port'],
userName: 'xxx',
password: 'xxx',
space: 'space name',
poolSize: 5,
bufferSize: 2000,
executeTimeout: 15000,
pingInterval: 60000
}
// Create client
const client = createClient(options)
// Execute command
// 1. return parsed data (recommend)
const response = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406')
// 2. return nebula original data
const responseOriginal = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406', true)
Whether you are a DBA, architect, or data scientist