25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(nebula): add NebulaGraph 3.x browser support
Hand Sonicef05a6a19b0c
diff --git a/.github/scripts/bump-agent-versions.mjs b/.github/scripts/bump-agent-versions.mjsindex 6b6bb6f814..310520a0a2 100644--- a/.github/scripts/bump-agent-versions.mjs+++ b/.github/scripts/bump-agent-versions.mjs@@ -57,6 +57,7 @@ const nativeDriverDirectories = {kingbase: "kingbase-go",iotdb: "iotdb",neo4j: "neo4j-go",+ nebula: "nebula-go",vastbase: "vastbase-go",rabbitmq: "rabbitmq",rocketmq: "rocketmq",@@ -68,7 +69,7 @@ const nativeDriverDirectories = {const crateNativeDriverDirectories = {"sqlite-worker": "crates/dbx-sqlite-worker",};-const nativeDriverModules = new Set(["cassandra", "duckdb", "hive", "argo", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "vastbase", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2", "sqlite-worker"]);+const nativeDriverModules = new Set(["cassandra", "duckdb", "hive", "argo", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "nebula", "vastbase", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2", "sqlite-worker"]);const nativeDriverSharedPaths = {hive: ["agents/go-common/go-gssapi",diff --git a/.github/scripts/ci-config.mjs b/.github/scripts/ci-config.mjsindex 91a256e41b..0aa5dd3bd1 100644--- a/.github/scripts/ci-config.mjs+++ b/.github/scripts/ci-config.mjs@@ -21,6 +21,7 @@ export const goAgents = [{ driver: "hive-go", binary: "hive", race: false },{ driver: "vastbase-go", binary: "vastbase", race: false },{ driver: "neo4j-go", binary: "neo4j", race: false },+ { driver: "nebula-go", binary: "nebula", race: false },{ driver: "iotdb", binary: "iotdb", race: false },];diff --git a/.github/scripts/ci-plan.test.mjs b/.github/scripts/ci-plan.test.mjsindex 57e3b98b72..e9e69ac780 100644--- a/.github/scripts/ci-plan.test.mjs+++ b/.github/scripts/ci-plan.test.mjs@@ -93,7 +93,7 @@ for (const file of ["Cargo.toml", "Cargo.lock", ".cargo/config.toml", "rust-toolconst result = plan([file]);assert.deepEqual(groups(result), ["workspace"]);assert.equal(result.rust_full, true);- assert.equal(result.agent_go.include.length, 10);+ assert.equal(result.agent_go.include.length, goAgents.length);assert.equal(result.agent_rust.include.length, 2);assert.equal(result.agent_integration.include.length, 16);assert.equal(result.agent_java, true);@@ -150,12 +150,12 @@ test("shared Agent inputs and unknown native modules never silently lose coveragfor (const file of ["agents/common/src/main/java/Protocol.java", "agents/scripts/validate_agents.py", "agents/build.gradle","agents/drivers/new-driver/main.go", "crates/dbx-driver-agent/assets/agent-protocol-v2.json", ".github/workflows/agents-release.yml"]) {const result = plan([file]);- assert.equal(result.agent_go.include.length, 10, file);+ assert.equal(result.agent_go.include.length, goAgents.length, file);assert.equal(result.agent_integration.include.length, 16, file);assert.equal(result.agent_java, true, file);}const fallback = plan(["future-agent-filter-input"], { agentsChanged: true });- assert.equal(fallback.agent_go.include.length, 10);+ assert.equal(fallback.agent_go.include.length, goAgents.length);assert.equal(fallback.agent_integration.include.length, 16);assert.equal(fallback.agent_java, true);});diff --git a/.github/scripts/label-pull-request.mjs b/.github/scripts/label-pull-request.mjsindex a81e06b25d..223b3afbdd 100644--- a/.github/scripts/label-pull-request.mjs+++ b/.github/scripts/label-pull-request.mjs@@ -56,6 +56,7 @@ const DRIVER_DATABASE_ALIASES = {kafka: "mq","kingbase-go": "kingbase","neo4j-go": "neo4j",+ "nebula-go": "nebula","oracle-10g": "oracle","oracle-go": "oracle","oracle-legacy": "oracle",diff --git a/.github/scripts/reuse-agent-release-assets.mjs b/.github/scripts/reuse-agent-release-assets.mjsindex 110c042261..ae27a018b9 100644--- a/.github/scripts/reuse-agent-release-assets.mjs+++ b/.github/scripts/reuse-agent-release-assets.mjs@@ -15,7 +15,7 @@ import { basename, join } from "node:path";import { tmpdir } from "node:os";const REGISTRY_ASSET = "agent-registry.json";-const NATIVE_MODULES = new Set(["duckdb", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "vastbase", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2"]);+const NATIVE_MODULES = new Set(["duckdb", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "nebula", "vastbase", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2"]);const PLATFORMS = ["macos-aarch64","macos-x64",diff --git a/.github/workflows/agents-release.yml b/.github/workflows/agents-release.ymlindex db8143d455..b43ce6a24f 100644--- a/.github/workflows/agents-release.yml+++ b/.github/workflows/agents-release.yml@@ -707,6 +707,44 @@ jobs:name: neo4j-nativepath: "release-native/dbx-agent-neo4j-*"+ build-nebula-native:+ needs: [bump-versions]+ if: ${{ contains(fromJSON(needs.bump-versions.outputs.native_modules), 'nebula') }}+ runs-on: ubuntu-latest+ steps:+ - uses: actions/checkout@v4+ - uses: actions/setup-go@v5+ with:+ go-version: "1.24.x"+ - name: Test NebulaGraph native agent+ working-directory: agents/drivers/nebula-go+ run: go test ./...+ - name: Cross-compile NebulaGraph native agent+ shell: bash+ run: |+ mkdir -p release-native+ cd agents/drivers/nebula-go+ declare -A TARGETS=(+ ["macos-aarch64"]="darwin/arm64"+ ["macos-x64"]="darwin/amd64"+ ["linux-aarch64"]="linux/arm64"+ ["linux-x64"]="linux/amd64"+ ["windows-aarch64"]="windows/arm64"+ ["windows-x64"]="windows/amd64"+ )+ for platform in "${!TARGETS[@]}"; do+ IFS=/ read -r goos goarch <<< "${TARGETS[$platform]}"+ output="../../../release-native/dbx-agent-nebula-${platform}"+ if [[ "$goos" == "windows" ]]; then+ output="${output}.exe"+ fi+ CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" go build -trimpath -ldflags="-s -w" -o "$output" .+ done+ - uses: actions/upload-artifact@v4+ with:+ name: nebula-native+ path: "release-native/dbx-agent-nebula-*"+build-iotdb-native:needs: [bump-versions]if: ${{ contains(fromJSON(needs.bump-versions.outputs.native_modules), 'iotdb') }}@@ -1257,7 +1295,7 @@ jobs:retention-days: 1release:- needs: [bump-versions, commit-versions, build-agents, build-oracle-native, build-xugu-native, build-rabbitmq-native, build-rocketmq-native, build-etcd-native, build-etcd2-native, build-zookeeper-native, build-cassandra-native, build-hive-native, build-argo-native, build-kingbase-native, build-vastbase-native, build-neo4j-native, build-iotdb-native, build-duckdb-native, build-sqlite-worker-native, build-tdengine-native, build-jre, reuse-previous-assets]+ needs: [bump-versions, commit-versions, build-agents, build-oracle-native, build-xugu-native, build-rabbitmq-native, build-rocketmq-native, build-etcd-native, build-etcd2-native, build-zookeeper-native, build-cassandra-native, build-hive-native, build-argo-native, build-kingbase-native, build-vastbase-native, build-neo4j-native, build-nebula-native, build-iotdb-native, build-duckdb-native, build-sqlite-worker-native, build-tdengine-native, build-jre, reuse-previous-assets]if: ${{ always() && !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}runs-on: ubuntu-lateststeps:@@ -1391,6 +1429,7 @@ jobs:hive) echo "Apache Hive" ;;argo) echo "星环Argo" ;;neo4j) echo "Neo4j" ;;+ nebula) echo "NebulaGraph" ;;iotdb) echo "Apache IoTDB" ;;tdengine) echo "TDengine" ;;etcd) echo "etcd" ;;@@ -1458,7 +1497,7 @@ jobs:[ -n "$DRIVERS" ] && DRIVERS="${DRIVERS},"$'\n'DRIVERS="${DRIVERS}$(generate_jar_entry "$name" "$label" "$f" "$jre_key" "$version" "$external_driver" "$native_json")"done- for name in oracle xugu kingbase vastbase neo4j iotdb duckdb sqlite-worker rabbitmq rocketmq zookeeper cassandra hive argo tdengine etcd etcd2; do+ for name in oracle xugu kingbase vastbase neo4j nebula iotdb duckdb sqlite-worker rabbitmq rocketmq zookeeper cassandra hive argo tdengine etcd etcd2; doversion=$(get_module_version "$name")[ -f "release/dbx-agent-${name}-${version}.jar" ] && continuenative_json=$(generate_native_platforms "$name" "$version")@@ -1548,6 +1587,7 @@ jobs:hive) echo "Apache Hive" ;;argo) echo "星环Argo" ;;neo4j) echo "Neo4j" ;;+ nebula) echo "NebulaGraph" ;;iotdb) echo "Apache IoTDB" ;;tdengine) echo "TDengine" ;;etcd) echo "etcd" ;;@@ -1600,6 +1640,8 @@ jobs:LOG_PATH="agents/drivers/argo-go/"elif [ "$name" = "neo4j" ]; thenLOG_PATH="agents/drivers/neo4j-go/"+ elif [ "$name" = "nebula" ]; then+ LOG_PATH="agents/drivers/nebula-go/"elif [ "$name" = "iotdb" ]; thenLOG_PATH="agents/drivers/iotdb/"elif [ "$name" = "sqlite-worker" ]; thendiff --git a/agents/README.md b/agents/README.mdindex 3b9147e879..add479359c 100644--- a/agents/README.md+++ b/agents/README.md@@ -35,6 +35,7 @@ Each agent runs as a standalone process and communicates with DBX via stdin/stdo| db2 | IBM DB2 | DB2 JDBC || informix | IBM Informix | Informix JDBC || neo4j | Neo4j | Official Neo4j Go Driver native agent |+| nebula | NebulaGraph 3.x | Official NebulaGraph Go Client native agent || cassandra | Apache Cassandra 2.1+ | Apache cassandra-gocql-driver native agent || bigquery | Google BigQuery | BigQuery JDBC || spanner | Google Cloud Spanner | Google Cloud Spanner JDBC |diff --git a/agents/README.zh-CN.md b/agents/README.zh-CN.mdindex cead6e6dda..f8c66ff57d 100644--- a/agents/README.zh-CN.md+++ b/agents/README.zh-CN.md@@ -35,6 +35,7 @@ DBX 的 Agent 驱动 —— 通过 JDBC 和原生数据库驱动支持各种数| db2 | IBM DB2 | DB2 JDBC || informix | IBM Informix | Informix JDBC || neo4j | Neo4j | 官方 Neo4j Go Driver 原生 Agent |+| nebula | NebulaGraph 3.x | 官方 NebulaGraph Go Client 原生 Agent || cassandra | Apache Cassandra 2.1+ | Apache cassandra-gocql-driver 原生 Agent || bigquery | Google BigQuery | BigQuery JDBC || spanner | Google Cloud Spanner | Google Cloud Spanner JDBC |diff --git a/agents/drivers/nebula-go/go.mod b/agents/drivers/nebula-go/go.modnew file mode 100644index 0000000000..a55b46a8f0--- /dev/null+++ b/agents/drivers/nebula-go/go.mod@@ -0,0 +1,11 @@+module github.com/t8y2/dbx/agents/drivers/nebula-go++go 1.24++require github.com/vesoft-inc/nebula-go/v3 v3.8.0++require (+ github.com/vesoft-inc/fbthrift v0.0.0-20230214024353-fa2f34755b28 // indirect+ golang.org/x/net v0.17.0 // indirect+ golang.org/x/text v0.13.0 // indirect+)diff --git a/agents/drivers/nebula-go/go.sum b/agents/drivers/nebula-go/go.sumnew file mode 100644index 0000000000..d44cf94e71--- /dev/null+++ b/agents/drivers/nebula-go/go.sum@@ -0,0 +1,55 @@+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=+github.com/vesoft-inc/fbthrift v0.0.0-20230214024353-fa2f34755b28 h1:gpoPCGeOEuk/TnoY9nLVK1FoBM5ie7zY3BPVG8q43ME=+github.com/vesoft-inc/fbthrift v0.0.0-20230214024353-fa2f34755b28/go.mod h1:xu7e9za8StcJhBZmCDwK1Hyv4/Y0xFsjS+uqp10ECJg=+github.com/vesoft-inc/nebula-go/v3 v3.8.0 h1:ecB87KMnMUcuKbgFESKIscdxA7Y1TcX7XEVqZQ1UqlA=+github.com/vesoft-inc/nebula-go/v3 v3.8.0/go.mod h1:YTNAQzimjXLXUaEDOzty/eCCye+9zkZRuUzXz9LQUpU=+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=+golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=diff --git a/agents/drivers/nebula-go/main.go b/agents/drivers/nebula-go/main.gonew file mode 100644index 0000000000..c47d3151ac--- /dev/null+++ b/agents/drivers/nebula-go/main.go@@ -0,0 +1,347 @@+package main++import (+ "bufio"+ "encoding/json"+ "errors"+ "fmt"+ "os"+ "strings"+ "sync"+ "sync/atomic"+ "time"++ nebula "github.com/vesoft-inc/nebula-go/v3"+)++const (+ legacySessionID = "__legacy__"+ maxSessions = 256+)++type request struct {+ ID json.RawMessage `json:"id"`+ Method string `json:"method"`+ Params map[string]json.RawMessage `json:"params"`+}++type response struct {+ JSONRPC string `json:"jsonrpc"`+ ID json.RawMessage `json:"id,omitempty"`+ Result any `json:"result,omitempty"`+ Error *rpcError `json:"error,omitempty"`+}++type connectParams struct {+ DriverProfile string `json:"driver_profile"`+ Host string `json:"host"`+ Port int `json:"port"`+ Database string `json:"database"`+ Username string `json:"username"`+ Password string `json:"password"`+ SSL bool `json:"ssl"`+ CACertPath string `json:"ca_cert_path"`+ ClientCertPath string `json:"client_cert_path"`+ ClientKeyPath string `json:"client_key_path"`+ ConnectTimeoutSecs int `json:"connect_timeout_secs"`+}++type agentSession struct {+ mu sync.Mutex+ pool *nebula.ConnectionPool+ conn *nebula.Session+ params connectParams+ cursors map[string]*queryCursor+ nextCursorID uint64+ closed bool+ canceled atomic.Bool+ closePool sync.Once+}++type runtimeServer struct {+ mu sync.RWMutex+ sessions map[string]*agentSession+}++func main() {+ runtime := &runtimeServer{sessions: make(map[string]*agentSession)}+ encoder := json.NewEncoder(os.Stdout)+ var output sync.Mutex+ var running sync.WaitGroup+ fmt.Fprintln(os.Stdout, `{"ready":true}`)+ scanner := bufio.NewScanner(os.Stdin)+ scanner.Buffer(make([]byte, 0, 64*1024), 512*1024*1024)+ for scanner.Scan() {+ line := strings.TrimSpace(scanner.Text())+ if line == "" {+ continue+ }+ var envelope request+ if json.Unmarshal([]byte(line), &envelope) == nil && envelope.Method == "shutdown" {+ running.Wait()+ result := runtime.handleLine(line)+ output.Lock()+ _ = encoder.Encode(result)+ output.Unlock()+ return+ }+ running.Add(1)+ go func(line string) {+ defer running.Done()+ result := runtime.handleLine(line)+ output.Lock()+ defer output.Unlock()+ if err := encoder.Encode(result); err != nil {+ fmt.Fprintln(os.Stderr, err)+ }+ }(line)+ }+ running.Wait()+ if err := scanner.Err(); err != nil {+ fmt.Fprintln(os.Stderr, err)+ }+ _ = runtime.closeAll()+}++func (r *runtimeServer) handleLine(line string) response {+ var req request+ if err := json.Unmarshal([]byte(line), &req); err != nil {+ return errorResponse(nil, "", "", err)+ }+ if len(req.ID) == 0 {+ req.ID = json.RawMessage("1")+ }+ result, err := r.dispatch(req.Method, req.Params)+ if err != nil {+ return errorResponse(req.ID, req.Method, stringParam(req.Params, "agentSessionId"), err)+ }+ return response{JSONRPC: "2.0", ID: req.ID, Result: result}+}++func (r *runtimeServer) dispatch(method string, params map[string]json.RawMessage) (any, error) {+ switch method {+ case "handshake":+ return map[string]any{+ "protocolVersion": 2, "agentProtocolVersion": 2,+ "capabilities": []string{"connect", "test_connection", "metadata", "query", "paged_query", "ddl", "multi_session", "structured_error_v1"},+ }, nil+ case "open_session", "connect":+ var options connectParams+ if err := decodeParams(params, &options); err != nil {+ return nil, err+ }+ id := stringParam(params, "agentSessionId")+ if method == "connect" {+ id = legacySessionID+ _ = r.closeSession(id)+ }+ if id == "" {+ return nil, errors.New("agentSessionId is required")+ }+ return map[string]bool{"ok": true}, r.openSession(id, options)+ case "test_connection":+ var options connectParams+ if err := decodeParams(params, &options); err != nil {+ return nil, err+ }+ session, err := newAgentSession(options)+ if err != nil {+ return nil, err+ }+ defer session.close()+ return map[string]bool{"ok": true}, nil+ case "close_session", "disconnect":+ id := stringParam(params, "agentSessionId")+ if method == "disconnect" {+ id = legacySessionID+ }+ return map[string]bool{"ok": true}, r.closeSession(id)+ case "shutdown":+ return map[string]bool{"ok": true}, r.closeAll()+ case "cancel_session":+ session, err := r.session(stringParam(params, "agentSessionId"))+ if err != nil {+ return nil, err+ }+ session.cancel()+ return map[string]bool{"ok": true}, nil+ }++ id := stringParam(params, "agentSessionId")+ if id == "" {+ id = legacySessionID+ }+ session, err := r.session(id)+ if err != nil {+ return nil, err+ }+ session.mu.Lock()+ defer session.mu.Unlock()+ if session.closed || session.canceled.Load() {+ return nil, errors.New("agent session is closed")+ }+ if method == "validate_session" || method == "validate_connection" {+ _, err := session.execute("SHOW SPACES", "")+ return map[string]bool{"ok": err == nil}, err+ }+ return session.dispatch(method, params)+}++func (r *runtimeServer) openSession(id string, options connectParams) error {+ r.mu.Lock()+ if _, exists := r.sessions[id]; exists {+ r.mu.Unlock()+ return fmt.Errorf("agent session already exists: %s", id)+ }+ if len(r.sessions) >= maxSessions {+ r.mu.Unlock()+ return errors.New("agent session limit reached")+ }+ r.mu.Unlock()+ session, err := newAgentSession(options)+ if err != nil {+ return err+ }+ r.mu.Lock()+ defer r.mu.Unlock()+ if _, exists := r.sessions[id]; exists {+ session.close()+ return fmt.Errorf("agent session already exists: %s", id)+ }+ if len(r.sessions) >= maxSessions {+ session.close()+ return errors.New("agent session limit reached")+ }+ r.sessions[id] = session+ return nil+}++func newAgentSession(options connectParams) (*agentSession, error) {+ if options.DriverProfile != "" && !strings.EqualFold(options.DriverProfile, "nebula") && !strings.EqualFold(options.DriverProfile, "nebula-v3") {+ return nil, fmt.Errorf("unsupported NebulaGraph driver profile %q; only NebulaGraph 3.x is supported", options.DriverProfile)+ }+ if strings.TrimSpace(options.Host) == "" {+ return nil, errors.New("NebulaGraph graphd host is required")+ }+ if options.Port <= 0 || options.Port > 65535 {+ return nil, errors.New("NebulaGraph graphd port is invalid")+ }+ config := nebula.GetDefaultConf()+ config.MaxConnPoolSize = 1+ config.MinConnPoolSize = 1+ if options.ConnectTimeoutSecs > 0 {+ config.TimeOut = time.Duration(options.ConnectTimeoutSecs) * time.Second+ } else {+ config.TimeOut = 15 * time.Second+ }+ hosts := []nebula.HostAddress{{Host: options.Host, Port: options.Port}}+ var pool *nebula.ConnectionPool+ var err error+ if options.SSL {+ if options.CACertPath == "" || options.ClientCertPath == "" || options.ClientKeyPath == "" {+ return nil, errors.New("NebulaGraph TLS requires CA, client certificate and client key paths")+ }+ tlsConfig, tlsErr := nebula.GetDefaultSSLConfig(options.CACertPath, options.ClientCertPath, options.ClientKeyPath)+ if tlsErr != nil {+ return nil, tlsErr+ }+ pool, err = nebula.NewSslConnectionPool(hosts, config, tlsConfig, nebula.DefaultLogger{})+ } else {+ pool, err = nebula.NewConnectionPool(hosts, config, nebula.DefaultLogger{})+ }+ if err != nil {+ return nil, err+ }+ conn, err := pool.GetSession(options.Username, options.Password)+ if err != nil {+ pool.Close()+ return nil, err+ }+ session := &agentSession{pool: pool, conn: conn, params: options, cursors: make(map[string]*queryCursor)}+ if _, err := session.execute("SHOW SPACES", ""); err != nil {+ session.close()+ return nil, err+ }+ return session, nil+}++func (r *runtimeServer) session(id string) (*agentSession, error) {+ r.mu.RLock()+ session := r.sessions[id]+ r.mu.RUnlock()+ if session == nil {+ return nil, fmt.Errorf("agent session not found: %s", id)+ }+ return session, nil+}++func (r *runtimeServer) closeSession(id string) error {+ r.mu.Lock()+ session := r.sessions[id]+ delete(r.sessions, id)+ r.mu.Unlock()+ if session != nil {+ session.mu.Lock()+ session.close()+ session.mu.Unlock()+ }+ return nil+}++func (r *runtimeServer) closeAll() error {+ r.mu.Lock()+ sessions := r.sessions+ r.sessions = make(map[string]*agentSession)+ r.mu.Unlock()+ for _, session := range sessions {+ session.mu.Lock()+ session.close()+ session.mu.Unlock()+ }+ return nil+}++func (s *agentSession) cancel() {+ s.canceled.Store(true)+ s.closePool.Do(func() { s.pool.Close() })+}++func (s *agentSession) close() {+ if s.closed {+ return+ }+ s.closed = true+ s.cursors = nil+ s.closePool.Do(func() {+ if !s.canceled.Load() {+ s.conn.Release()+ }+ s.pool.Close()+ })+}++func decodeParams(params map[string]json.RawMessage, target any) error {+ data, err := json.Marshal(params)+ if err != nil {+ return err+ }+ return json.Unmarshal(data, target)+}++func stringParam(params map[string]json.RawMessage, key string) string {+ var value string+ _ = json.Unmarshal(params[key], &value)+ return value+}++func intParam(params map[string]json.RawMessage, key string) int {+ var value int+ _ = json.Unmarshal(params[key], &value)+ return value+}++func stringSliceParam(params map[string]json.RawMessage, key string) []string {+ var values []string+ _ = json.Unmarshal(params[key], &values)+ return values+}diff --git a/agents/drivers/nebula-go/main_test.go b/agents/drivers/nebula-go/main_test.gonew file mode 100644index 0000000000..c4806444cb--- /dev/null+++ b/agents/drivers/nebula-go/main_test.go@@ -0,0 +1,135 @@+package main++import (+ "encoding/json"+ "reflect"+ "strings"+ "testing"++ nebula "github.com/vesoft-inc/nebula-go/v3"+ wire "github.com/vesoft-inc/nebula-go/v3/nebula"+ "github.com/vesoft-inc/nebula-go/v3/nebula/graph"+)++func resultSet(t *testing.T, names []string, rows [][]*wire.Value) *nebula.ResultSet {+ t.Helper()+ columns := make([][]byte, len(names))+ for index, name := range names {+ columns[index] = []byte(name)+ }+ data := &wire.DataSet{ColumnNames: columns}+ for _, row := range rows {+ data.Rows = append(data.Rows, &wire.Row{Values: row})+ }+ result, err := nebula.GenResultSet(&graph.ExecutionResponse{ErrorCode: wire.ErrorCode_SUCCEEDED, Data: data})+ if err != nil {+ t.Fatal(err)+ }+ return result+}++func TestHandshakeMatchesAgentProtocol(t *testing.T) {+ runtime := &runtimeServer{sessions: make(map[string]*agentSession)}+ response := runtime.handleLine(`{"jsonrpc":"2.0","id":7,"method":"handshake","params":{}}`)+ if response.Error != nil {+ t.Fatalf("unexpected handshake error: %#v", response.Error)+ }+ result := response.Result.(map[string]any)+ if result["protocolVersion"] != 2 {+ t.Fatalf("unexpected protocol: %#v", result)+ }+ capabilities := result["capabilities"].([]string)+ if !strings.Contains(strings.Join(capabilities, ","), "multi_session") {+ t.Fatalf("missing multi-session capability: %#v", capabilities)+ }+}++func TestDriverProfileSupportsV3AndLegacyConnections(t *testing.T) {+ for _, profile := range []string{"", "nebula", "nebula-v3"} {+ _, err := newAgentSession(connectParams{DriverProfile: profile})+ if err == nil || !strings.Contains(err.Error(), "graphd host is required") {+ t.Fatalf("profile %q unexpectedly rejected: %v", profile, err)+ }+ }+ _, err := newAgentSession(connectParams{DriverProfile: "nebula-v5"})+ if err == nil || !strings.Contains(err.Error(), "only NebulaGraph 3.x is supported") {+ t.Fatalf("unsupported profile was not rejected: %v", err)+ }+}++func TestMissingSessionReturnsValidErrorContract(t *testing.T) {+ runtime := &runtimeServer{sessions: make(map[string]*agentSession)}+ response := runtime.handleLine(`{"jsonrpc":"2.0","id":7,"method":"execute_query","params":{"agentSessionId":"missing","sql":"SHOW SPACES"}}`)+ if response.Error == nil || response.Error.Data == nil {+ t.Fatalf("missing structured error: %#v", response)+ }+ data := response.Error.Data+ if data.ContractVersion != 1 || data.Stage != "execute" || data.OperationOutcome != "unknown" || data.AgentSessionID != "missing" || data.Category != "protocol" {+ t.Fatalf("invalid error contract: %#v", data)+ }+ if _, err := json.Marshal(response); err != nil {+ t.Fatal(err)+ }+}++func TestQueryErrorClassifiesAsSQLWithoutSQLState(t *testing.T) {+ response := errorResponse(json.RawMessage("1"), "execute_query", "session-1", &nebulaQueryError{code: "-1004", message: "syntax error"})+ if response.Error.Data.Category != "sql" || response.Error.Data.SessionDisposition != "keep" {+ t.Fatalf("unexpected SQL error: %#v", response.Error)+ }+ if !strings.Contains(response.Error.Message, "-1004") {+ t.Fatalf("NebulaGraph error code missing: %q", response.Error.Message)+ }+}++func TestQuoteNebulaIdentifier(t *testing.T) {+ quoted, err := quoteNebulaIdentifier("edge`name\\part")+ if err != nil || quoted != "`edge\\`name\\\\part`" {+ t.Fatalf("quoted = %q, err = %v", quoted, err)+ }+ if _, err := quoteNebulaIdentifier("a\nb"); err == nil {+ t.Fatal("control characters must not be accepted")+ }+}++func TestReadRowsPreservesScalarAndGraphValues(t *testing.T) {+ count := int64(42)+ nullValue := wire.NullType___NULL__+ value := resultSet(t, []string{"name", "count", "missing"}, [][]*wire.Value{{+ {SVal: []byte("Ada")}, {IVal: &count}, {NVal: &nullValue},+ }})+ rows, types, err := readRows(value, 10)+ if err != nil {+ t.Fatal(err)+ }+ if !reflect.DeepEqual(rows, [][]any{{"Ada", "42", nil}}) || !reflect.DeepEqual(types, []string{"string", "int", "Unknown"}) {+ t.Fatalf("rows=%#v types=%#v", rows, types)+ }+ metadata, err := metadataRows(value)+ if err != nil || metadata[0]["name"] != "Ada" || metadata[0]["count"] != "42" {+ t.Fatalf("metadata=%#v err=%v", metadata, err)+ }+}++func TestFetchQueryPageAdvancesWithoutReexecuting(t *testing.T) {+ session := &agentSession{cursors: map[string]*queryCursor{+ "page-1": {result: queryResult{Columns: []string{"n"}, ColumnTypes: []string{"int"}, Rows: [][]any{{"1"}, {"2"}, {"3"}}}, offset: 1},+ }}+ page, err := session.fetchQueryPage("page-1", 1)+ if err != nil || !page.HasMore || !reflect.DeepEqual(page.Rows, [][]any{{"2"}}) {+ t.Fatalf("page=%#v err=%v", page, err)+ }+ last, err := session.fetchQueryPage("page-1", 1)+ if err != nil || last.HasMore || !reflect.DeepEqual(last.Rows, [][]any{{"3"}}) || len(session.cursors) != 0 {+ t.Fatalf("last=%#v err=%v cursors=%d", last, err, len(session.cursors))+ }+}++func TestMetadataKindsRemainSeparate(t *testing.T) {+ if !acceptsObjectType([]string{"TABLE"}, "TABLE") || acceptsObjectType([]string{"TABLE"}, "VIEW") {+ t.Fatal("tag and edge types were mixed")+ }+ if !acceptsObjectType([]string{"EDGE"}, "VIEW") || !acceptsObjectType(nil, "TABLE") {+ t.Fatal("edge alias or unrestricted metadata lookup failed")+ }+}diff --git a/agents/drivers/nebula-go/metadata.go b/agents/drivers/nebula-go/metadata.gonew file mode 100644index 0000000000..47f4eeeb93--- /dev/null+++ b/agents/drivers/nebula-go/metadata.go@@ -0,0 +1,282 @@+package main++import (+ "encoding/json"+ "errors"+ "fmt"+ "sort"+ "strings"+ "unicode"++ nebula "github.com/vesoft-inc/nebula-go/v3"+)++type databaseInfo struct {+ Name string `json:"name"`+}++type tableInfo struct {+ Name string `json:"name"`+ TableType string `json:"table_type"`+ Comment *string `json:"comment"`+}++type objectInfo struct {+ Name string `json:"name"`+ ObjectType string `json:"object_type"`+ Schema string `json:"schema"`+ Comment *string `json:"comment"`+}++type columnInfo struct {+ Name string `json:"name"`+ DataType string `json:"data_type"`+ IsNullable bool `json:"is_nullable"`+ ColumnDefault *string `json:"column_default"`+ IsPrimaryKey bool `json:"is_primary_key"`+ Extra *string `json:"extra"`+ Comment *string `json:"comment"`+ NumericPrecision *int `json:"numeric_precision"`+ NumericScale *int `json:"numeric_scale"`+ CharacterMaximumLength *int `json:"character_maximum_length"`+}++type objectSource struct {+ Name string `json:"name"`+ ObjectType string `json:"object_type"`+ Schema *string `json:"schema"`+ Source string `json:"source"`+}++func (s *agentSession) listDatabases() ([]databaseInfo, error) {+ result, err := s.execute("SHOW SPACES", "")+ if err != nil {+ return nil, err+ }+ rows, err := metadataRows(result)+ if err != nil {+ return nil, err+ }+ spaces := make([]databaseInfo, 0, len(rows))+ for _, row := range rows {+ name := firstMetadataValue(row, "Name")+ if name != "" {+ spaces = append(spaces, databaseInfo{Name: name})+ }+ }+ sort.Slice(spaces, func(i, j int) bool { return spaces[i].Name < spaces[j].Name })+ return spaces, nil+}++func (s *agentSession) listTables(params map[string]json.RawMessage) ([]tableInfo, error) {+ space := selectedSpace(stringParam(params, "database"), s.params.Database)+ if space == "" {+ return []tableInfo{}, nil+ }+ filter := strings.ToLower(strings.TrimSpace(stringParam(params, "filter")))+ requestedTypes := stringSliceParam(params, "object_types")+ if len(requestedTypes) == 0 {+ requestedTypes = stringSliceParam(params, "objectTypes")+ }+ tables := make([]tableInfo, 0)+ for _, kind := range []struct{ typeName, statement string }{{"TABLE", "SHOW TAGS"}, {"VIEW", "SHOW EDGES"}} {+ if !acceptsObjectType(requestedTypes, kind.typeName) {+ continue+ }+ result, err := s.execute(kind.statement, space)+ if err != nil {+ return nil, err+ }+ rows, err := metadataRows(result)+ if err != nil {+ return nil, err+ }+ for _, row := range rows {+ name := firstMetadataValue(row, "Name")+ if name != "" && strings.Contains(strings.ToLower(name), filter) {+ tables = append(tables, tableInfo{Name: name, TableType: kind.typeName})+ }+ }+ }+ sort.Slice(tables, func(i, j int) bool {+ if tables[i].TableType != tables[j].TableType {+ return tables[i].TableType < tables[j].TableType+ }+ return tables[i].Name < tables[j].Name+ })+ offset, limit := intParam(params, "offset"), intParam(params, "limit")+ if offset < 0 {+ offset = 0+ }+ if offset >= len(tables) {+ return []tableInfo{}, nil+ }+ tables = tables[offset:]+ if limit > 0 && limit < len(tables) {+ tables = tables[:limit]+ }+ return tables, nil+}++func (s *agentSession) listObjects(params map[string]json.RawMessage) ([]objectInfo, error) {+ tables, err := s.listTables(params)+ if err != nil {+ return nil, err+ }+ objects := make([]objectInfo, 0, len(tables))+ for _, table := range tables {+ objects = append(objects, objectInfo{Name: table.Name, ObjectType: table.TableType, Schema: ""})+ }+ return objects, nil+}++func (s *agentSession) getColumns(database, name string) ([]columnInfo, error) {+ space := selectedSpace(database, s.params.Database)+ if space == "" {+ return nil, errors.New("select a NebulaGraph space before reading object columns")+ }+ quoted, err := quoteNebulaIdentifier(name)+ if err != nil {+ return nil, err+ }+ result, err := s.execute("DESCRIBE TAG "+quoted, space)+ if err != nil {+ result, err = s.execute("DESCRIBE EDGE "+quoted, space)+ if err != nil {+ return nil, err+ }+ }+ rows, err := metadataRows(result)+ if err != nil {+ return nil, err+ }+ columns := make([]columnInfo, 0, len(rows))+ for _, row := range rows {+ field := firstMetadataValue(row, "Field")+ if field == "" {+ continue+ }+ columns = append(columns, columnInfo{+ Name: field, DataType: firstMetadataValue(row, "Type"),+ IsNullable: !strings.EqualFold(firstMetadataValue(row, "Null"), "NO"),+ ColumnDefault: optionalMetadataValue(row, "Default"), Comment: optionalMetadataValue(row, "Comment"),+ })+ }+ return columns, nil+}++func (s *agentSession) getTableDDL(database, name, objectType string) (string, error) {+ space := selectedSpace(database, s.params.Database)+ if space == "" {+ return "", errors.New("select a NebulaGraph space before reading object DDL")+ }+ quoted, err := quoteNebulaIdentifier(name)+ if err != nil {+ return "", err+ }+ kinds := []string{"TAG", "EDGE"}+ if strings.EqualFold(objectType, "VIEW") || strings.EqualFold(objectType, "EDGE") {+ kinds = []string{"EDGE"}+ }+ for _, kind := range kinds {+ result, queryErr := s.execute("SHOW CREATE "+kind+" "+quoted, space)+ if queryErr != nil {+ if kind == kinds[len(kinds)-1] {+ return "", queryErr+ }+ continue+ }+ rows, readErr := metadataRows(result)+ if readErr != nil {+ return "", readErr+ }+ if len(rows) > 0 {+ for key, value := range rows[0] {+ if strings.HasPrefix(strings.ToLower(key), "create ") {+ return value, nil+ }+ }+ }+ }+ return "", nil+}++func (s *agentSession) getObjectSource(params map[string]json.RawMessage) (objectSource, error) {+ name := stringParam(params, "name")+ objectType := strings.ToUpper(stringParam(params, "object_type"))+ if objectType == "" {+ objectType = strings.ToUpper(stringParam(params, "objectType"))+ }+ source, err := s.getTableDDL(stringParam(params, "database"), name, objectType)+ if err != nil {+ return objectSource{}, err+ }+ return objectSource{Name: name, ObjectType: objectType, Source: source}, nil+}++func selectedSpace(requested, configured string) string {+ if strings.TrimSpace(requested) != "" {+ return strings.TrimSpace(requested)+ }+ return strings.TrimSpace(configured)+}++func quoteNebulaIdentifier(name string) (string, error) {+ if name == "" || strings.IndexFunc(name, unicode.IsControl) >= 0 {+ return "", fmt.Errorf("invalid NebulaGraph identifier: %q", name)+ }+ escaped := strings.ReplaceAll(strings.ReplaceAll(name, `\`, `\\`), "`", "\\`")+ return "`" + escaped + "`", nil+}++func acceptsObjectType(requested []string, kind string) bool {+ if len(requested) == 0 {+ return true+ }+ for _, candidate := range requested {+ if strings.EqualFold(candidate, kind) || (kind == "TABLE" && strings.EqualFold(candidate, "TAG")) || (kind == "VIEW" && strings.EqualFold(candidate, "EDGE")) {+ return true+ }+ }+ return false+}++func metadataRows(result *nebula.ResultSet) ([]map[string]string, error) {+ columns := result.GetColNames()+ rows := make([]map[string]string, 0, len(result.GetRows()))+ for index := range result.GetRows() {+ record, err := result.GetRowValuesByIndex(index)+ if err != nil {+ return nil, err+ }+ row := make(map[string]string, len(columns))+ for column, name := range columns {+ value, err := record.GetValueByIndex(column)+ if err != nil {+ return nil, err+ }+ if normalized := normalizeValue(value); normalized != nil {+ row[name] = fmt.Sprint(normalized)+ }+ }+ rows = append(rows, row)+ }+ return rows, nil+}++func firstMetadataValue(row map[string]string, name string) string {+ for key, value := range row {+ if strings.EqualFold(key, name) {+ return value+ }+ }+ return ""+}++func optionalMetadataValue(row map[string]string, name string) *string {+ value := firstMetadataValue(row, name)+ if value == "" || strings.EqualFold(value, "NULL") {+ return nil+ }+ return &value+}diff --git a/agents/drivers/nebula-go/protocol_error.go b/agents/drivers/nebula-go/protocol_error.gonew file mode 100644index 0000000000..45406acb4c--- /dev/null+++ b/agents/drivers/nebula-go/protocol_error.go@@ -0,0 +1,79 @@+package main++import (+ "encoding/json"+ "errors"+ "io"+ "net"+ "strings"+)++type rpcError struct {+ Code int `json:"code"`+ Message string `json:"message"`+ Data *rpcErrorData `json:"data"`+}++type rpcErrorData struct {+ ContractVersion int `json:"contractVersion"`+ Category string `json:"category"`+ Retryable bool `json:"retryable"`+ SessionDisposition string `json:"sessionDisposition"`+ Stage string `json:"stage"`+ OperationOutcome string `json:"operationOutcome"`+ AgentSessionID string `json:"agentSessionId,omitempty"`+}++func errorResponse(id json.RawMessage, method, sessionID string, err error) response {+ stage := errorStage(method)+ data := &rpcErrorData{+ ContractVersion: 1, Category: "protocol", SessionDisposition: "keep",+ Stage: stage, OperationOutcome: errorOutcome(stage), AgentSessionID: strings.TrimSpace(sessionID),+ }+ var queryError *nebulaQueryError+ if errors.As(err, &queryError) {+ if stage == "execute" || stage == "fetch" {+ data.Category = "sql"+ } else {+ data.Category = "connection"+ }+ } else if errors.Is(err, io.EOF) || isNetworkError(err) {+ data.Category = "connection"+ data.Retryable = stage == "connect" || stage == "validate"+ if stage == "execute" || stage == "fetch" {+ data.SessionDisposition = "quarantine"+ }+ }+ return response{JSONRPC: "2.0", ID: id, Error: &rpcError{Code: -1, Message: err.Error(), Data: data}}+}++func errorStage(method string) string {+ switch method {+ case "open_session", "connect", "test_connection":+ return "connect"+ case "validate_session", "validate_connection":+ return "validate"+ case "fetch_query_page", "fetch_table_read_page":+ return "fetch"+ case "cancel_session":+ return "cancel"+ case "close_session", "disconnect", "close_query_session", "close_table_read_session", "shutdown":+ return "close"+ case "handshake", "":+ return "request"+ default:+ return "execute"+ }+}++func errorOutcome(stage string) string {+ if stage == "request" || stage == "connect" || stage == "validate" {+ return "not_started"+ }+ return "unknown"+}++func isNetworkError(err error) bool {+ var networkError net.Error+ return errors.As(err, &networkError)+}diff --git a/agents/drivers/nebula-go/query.go b/agents/drivers/nebula-go/query.gonew file mode 100644index 0000000000..066d27b768--- /dev/null+++ b/agents/drivers/nebula-go/query.go@@ -0,0 +1,262 @@+package main++import (+ "encoding/json"+ "errors"+ "fmt"+ "strings"+ "time"++ nebula "github.com/vesoft-inc/nebula-go/v3"+)++const (+ defaultMaxRows = 10000+ maxQueryRows = 100000+ defaultPage = 1000+)++type queryOptions struct {+ SQL string `json:"sql"`+ Database string `json:"database"`+ MaxRows int `json:"maxRows"`+ TimeoutSecs int `json:"timeoutSecs"`+}++type queryResult struct {+ Columns []string `json:"columns"`+ ColumnTypes []string `json:"column_types"`+ Rows [][]any `json:"rows"`+ AffectedRows int64 `json:"affected_rows"`+ ExecutionTimeMS int64 `json:"execution_time_ms"`+ Truncated bool `json:"truncated"`+}++type queryPageResult struct {+ queryResult+ SessionID *string `json:"session_id"`+ HasMore bool `json:"has_more"`+}++type queryCursor struct {+ result queryResult+ offset int+}++func (s *agentSession) dispatch(method string, params map[string]json.RawMessage) (any, error) {+ switch method {+ case "connection_info":+ return map[string]any{+ "database": s.params.Database, "schema": "", "username": s.params.Username,+ "identifierQuote": "`", "compatibilityMode": "ngql",+ "databaseInfo": map[string]string{+ "productName": "NebulaGraph", "driverName": "NebulaGraph Go Client", "driverVersion": "3.8.0",+ "unquotedIdentifierCase": "mixed", "quotedIdentifierCase": "mixed",+ },+ }, nil+ case "list_databases":+ return s.listDatabases()+ case "list_schemas":+ return []string{}, nil+ case "list_tables":+ return s.listTables(params)+ case "list_objects":+ return s.listObjects(params)+ case "list_data_types":+ return []string{"bool", "int8", "int16", "int32", "int64", "float", "double", "string", "fixed_string", "date", "time", "datetime", "timestamp", "duration", "geography"}, nil+ case "get_columns":+ return s.getColumns(stringParam(params, "database"), stringParam(params, "table"))+ case "get_table_ddl":+ return s.getTableDDL(stringParam(params, "database"), stringParam(params, "table"), "")+ case "get_object_source":+ return s.getObjectSource(params)+ case "get_table_comment":+ return nil, nil+ case "list_indexes", "list_foreign_keys", "list_triggers", "list_constraints", "list_partitions", "list_subpartitions":+ return []any{}, nil+ case "get_explain_info":+ return map[string]any{"plan": "", "has_actual_stats": false}, nil+ case "execute_query":+ var options queryOptions+ if err := decodeParams(params, &options); err != nil {+ return nil, err+ }+ return s.executeQuery(options)+ case "execute_query_page", "start_table_read":+ var options queryOptions+ if err := decodeParams(params, &options); err != nil {+ return nil, err+ }+ return s.executeQueryPage(options, intParam(params, "pageSize"))+ case "fetch_query_page", "fetch_table_read_page":+ return s.fetchQueryPage(stringParam(params, "sessionId"), intParam(params, "pageSize"))+ case "close_query_session", "close_table_read_session":+ delete(s.cursors, stringParam(params, "sessionId"))+ return map[string]bool{"ok": true}, nil+ case "execute_batch":+ started := time.Now()+ for _, statement := range stringSliceParam(params, "statements") {+ _, err := s.executeQuery(queryOptions{SQL: statement, Database: stringParam(params, "database")})+ if err != nil {+ return nil, err+ }+ }+ return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, ExecutionTimeMS: time.Since(started).Milliseconds()}, nil+ default:+ return nil, fmt.Errorf("unsupported NebulaGraph agent method: %s", method)+ }+}++func (s *agentSession) execute(statement, space string) (*nebula.ResultSet, error) {+ if s.canceled.Load() {+ return nil, errors.New("agent session was canceled")+ }+ if space = strings.TrimSpace(space); space != "" {+ quoted, err := quoteNebulaIdentifier(space)+ if err != nil {+ return nil, err+ }+ selected, err := s.conn.Execute("USE " + quoted)+ if err != nil {+ return nil, err+ }+ if err := resultError(selected); err != nil {+ return nil, err+ }+ }+ result, err := s.conn.Execute(statement)+ if err != nil {+ return nil, err+ }+ if err := resultError(result); err != nil {+ return nil, err+ }+ return result, nil+}++func (s *agentSession) executeQuery(options queryOptions) (queryResult, error) {+ started := time.Now()+ statement := strings.TrimSpace(options.SQL)+ if statement == "" {+ return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}}, nil+ }+ space := options.Database+ if space == "" {+ space = s.params.Database+ }+ result, err := s.execute(statement, space)+ if err != nil {+ return queryResult{}, err+ }+ rows, types, err := readRows(result, effectiveMaxRows(options.MaxRows))+ if err != nil {+ return queryResult{}, err+ }+ return queryResult{+ Columns: result.GetColNames(), ColumnTypes: types, Rows: rows,+ ExecutionTimeMS: time.Since(started).Milliseconds(), Truncated: len(result.GetRows()) > len(rows),+ }, nil+}++func (s *agentSession) executeQueryPage(options queryOptions, pageSize int) (queryPageResult, error) {+ result, err := s.executeQuery(options)+ if err != nil {+ return queryPageResult{}, err+ }+ if pageSize <= 0 {+ pageSize = defaultPage+ }+ if pageSize >= len(result.Rows) {+ return queryPageResult{queryResult: result}, nil+ }+ s.nextCursorID+++ id := fmt.Sprintf("nebula-query-%d", s.nextCursorID)+ s.cursors[id] = &queryCursor{result: result, offset: pageSize}+ result.Rows = result.Rows[:pageSize]+ return queryPageResult{queryResult: result, SessionID: &id, HasMore: true}, nil+}++func (s *agentSession) fetchQueryPage(id string, pageSize int) (queryPageResult, error) {+ cursor := s.cursors[id]+ if cursor == nil {+ return queryPageResult{}, fmt.Errorf("query session not found: %s", id)+ }+ if pageSize <= 0 {+ pageSize = defaultPage+ }+ end := min(cursor.offset+pageSize, len(cursor.result.Rows))+ result := cursor.result+ result.Rows = result.Rows[cursor.offset:end]+ cursor.offset = end+ if end == len(cursor.result.Rows) {+ delete(s.cursors, id)+ return queryPageResult{queryResult: result}, nil+ }+ return queryPageResult{queryResult: result, SessionID: &id, HasMore: true}, nil+}++func effectiveMaxRows(requested int) int {+ if requested <= 0 {+ return defaultMaxRows+ }+ return min(requested, maxQueryRows)+}++func readRows(result *nebula.ResultSet, limit int) ([][]any, []string, error) {+ columns := result.GetColNames()+ rows := make([][]any, 0, min(len(result.GetRows()), limit))+ types := make([]string, len(columns))+ for i := range types {+ types[i] = "Unknown"+ }+ for index := 0; index < len(result.GetRows()) && index < limit; index++ {+ record, err := result.GetRowValuesByIndex(index)+ if err != nil {+ return nil, nil, err+ }+ row := make([]any, len(columns))+ for column := range columns {+ value, err := record.GetValueByIndex(column)+ if err != nil {+ return nil, nil, err+ }+ if types[column] == "Unknown" && value.GetType() != "null" {+ types[column] = value.GetType()+ }+ row[column] = normalizeValue(value)+ }+ rows = append(rows, row)+ }+ return rows, types, nil+}++func normalizeValue(value *nebula.ValueWrapper) any {+ if value == nil || value.GetType() == "null" {+ return nil+ }+ if value.GetType() == "string" {+ if text, err := value.AsString(); err == nil {+ return text+ }+ }+ return value.String()+}++type nebulaQueryError struct {+ code string+ message string+}++func (err *nebulaQueryError) Error() string {+ return fmt.Sprintf("NebulaGraph error %s: %s", err.code, err.message)+}++func resultError(result *nebula.ResultSet) error {+ if result == nil {+ return errors.New("NebulaGraph returned no result")+ }+ if !result.IsSucceed() {+ return &nebulaQueryError{code: fmt.Sprint(result.GetErrorCode()), message: result.GetErrorMsg()}+ }+ return nil+}diff --git a/agents/metadata-constraint-coverage.tsv b/agents/metadata-constraint-coverage.tsvindex b3345f91a5..1e695d6264 100644--- a/agents/metadata-constraint-coverage.tsv+++ b/agents/metadata-constraint-coverage.tsv@@ -21,6 +21,7 @@ kingbase-go shared-fallback native-go Uses sys_catalog/information_schema for covastbase-go shared-fallback native-go Uses pg_catalog/information_schema for Vastbase metadata, then applies stable filtering and paging in the native agent.kylin intentional-fallback java-jdbc-metadata Uses JDBC metadata from Kylin driver; no portable server-side paging API, common constraints filter locally.neo4j-go shared-fallback native-go Uses Neo4j schema procedures with stable local filtering and paging because label discovery does not expose portable server-side metadata pagination.+nebula-go shared-fallback native-go Uses SHOW TAGS and SHOW EDGES with stable local filtering and paging because nGQL metadata listing has no server-side pagination.oceanbase-oracle native-pushdown java-sql Uses Oracle-compatible metadata SQL with type, filter, stable order, and ROWNUM paging.oracle-go native-pushdown native-go Uses Oracle-compatible metadata SQL with type, filter, stable order, and ROWNUM paging, with legacy profile guard.snowflake native-pushdown java-sql Uses INFORMATION_SCHEMA with type, filter, stable order, and literal LIMIT/OFFSET.diff --git a/agents/scripts/driver_release_packages_test.py b/agents/scripts/driver_release_packages_test.pyindex da3da6e02b..7773a9cde4 100644--- a/agents/scripts/driver_release_packages_test.py+++ b/agents/scripts/driver_release_packages_test.py@@ -28,6 +28,8 @@ class DriverReleasePackagesTest(unittest.TestCase):rocketmq_source.write_bytes(b"MZtest-rocketmq-agent")cassandra_source = release_dir / "dbx-agent-cassandra-linux-x64"cassandra_source.write_bytes(b"\x7fELFtest-cassandra-agent")+ nebula_source = release_dir / "dbx-agent-nebula-linux-aarch64"+ nebula_source.write_bytes(b"\x7fELFtest-nebula-agent")tdengine_source = release_dir / "dbx-agent-tdengine-windows-aarch64.exe"tdengine_source.write_bytes(b"MZtest-tdengine-agent")etcd_source = release_dir / "dbx-agent-etcd-linux-x64"@@ -43,6 +45,7 @@ class DriverReleasePackagesTest(unittest.TestCase):"kingbase": "0.1.34","iotdb": "0.1.30","neo4j": "0.1.40",+ "nebula": "0.1.0","vastbase": "0.1.37","duckdb": "0.1.0","rabbitmq": "0.1.0",@@ -66,6 +69,7 @@ class DriverReleasePackagesTest(unittest.TestCase):versioned_rabbitmq = release_dir / "dbx-agent-rabbitmq-0.1.0-linux-x64"versioned_rocketmq = release_dir / "dbx-agent-rocketmq-0.1.0-windows-x64.exe"versioned_cassandra = release_dir / "dbx-agent-cassandra-0.1.37-linux-x64"+ versioned_nebula = release_dir / "dbx-agent-nebula-0.1.0-linux-aarch64"versioned_tdengine = release_dir / "dbx-agent-tdengine-0.1.0-windows-aarch64.exe"versioned_etcd = release_dir / "dbx-agent-etcd-0.1.40-linux-x64"versioned_etcd2 = release_dir / "dbx-agent-etcd2-0.1.0-macos-aarch64"@@ -75,6 +79,7 @@ class DriverReleasePackagesTest(unittest.TestCase):versioned_java,versioned_cassandra,versioned_native,+ versioned_nebula,versioned_vastbase,versioned_duckdb,versioned_rabbitmq,@@ -262,6 +267,7 @@ class DriverReleasePackagesTest(unittest.TestCase):versioned_etcd2,versioned_java,versioned_native,+ versioned_nebula,versioned_rabbitmq,versioned_rocketmq,versioned_tdengine,@@ -285,6 +291,20 @@ class DriverReleasePackagesTest(unittest.TestCase):self.assertFalse(source.exists())self.assertEqual(versioned.read_bytes(), b"\xcf\xfa\xed\xfetest-neo4j-agent")+ def test_versions_nebula_native_artifacts(self) -> None:+ with tempfile.TemporaryDirectory() as temp_dir:+ release_dir = Path(temp_dir)+ source = release_dir / "dbx-agent-nebula-linux-aarch64"+ source.write_bytes(b"\x7fELFtest-nebula-agent")+ versions = {driver: "0.1.0" for driver in NATIVE_DRIVERS}++ renamed = version_agent_artifacts(release_dir, versions)+ versioned = release_dir / "dbx-agent-nebula-0.1.0-linux-aarch64"++ self.assertEqual(renamed, [versioned])+ self.assertFalse(source.exists())+ self.assertEqual(versioned.read_bytes(), b"\x7fELFtest-nebula-agent")+def test_versions_iotdb_native_artifacts(self) -> None:with tempfile.TemporaryDirectory() as temp_dir:release_dir = Path(temp_dir)diff --git a/agents/scripts/validate_agents.py b/agents/scripts/validate_agents.pyindex 3a8e6c7f64..cad121643f 100644--- a/agents/scripts/validate_agents.py+++ b/agents/scripts/validate_agents.py@@ -21,6 +21,7 @@ NATIVE_ONLY_AGENT_MODULES = {"kingbase": "drivers/kingbase-go","iotdb": "drivers/iotdb","neo4j": "drivers/neo4j-go",+ "nebula": "drivers/nebula-go","vastbase": "drivers/vastbase-go","tdengine": "drivers/tdengine","xugu": "drivers/xugu",diff --git a/agents/scripts/version_agent_artifacts.py b/agents/scripts/version_agent_artifacts.pyindex 038f5bb6fd..238f7abdeb 100644--- a/agents/scripts/version_agent_artifacts.py+++ b/agents/scripts/version_agent_artifacts.py@@ -4,7 +4,7 @@ import jsonfrom pathlib import Path-NATIVE_DRIVERS = ("cassandra", "hive", "argo", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "vastbase", "duckdb", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2", "sqlite-worker")+NATIVE_DRIVERS = ("cassandra", "hive", "argo", "oracle", "xugu", "kingbase", "iotdb", "neo4j", "nebula", "vastbase", "duckdb", "rabbitmq", "rocketmq", "zookeeper", "tdengine", "etcd", "etcd2", "sqlite-worker")PLATFORMS = ("macos-aarch64","macos-x64",diff --git a/agents/versions.json b/agents/versions.jsonindex 5d8c15ab5f..a3381da6f8 100644--- a/agents/versions.json+++ b/agents/versions.json@@ -24,6 +24,7 @@"kingbase": "0.1.59","kylin": "0.1.69","neo4j": "0.1.49",+ "nebula": "0.1.0","oceanbase-oracle": "0.1.66","oracle": "0.1.65","snowflake": "0.1.69",diff --git a/apps/desktop/public/icons/database/nebula.png b/apps/desktop/public/icons/database/nebula.pngnew file mode 100644index 0000000000..45df6ec4aeBinary files /dev/null and b/apps/desktop/public/icons/database/nebula.png differdiff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vueindex 5f1c38b8e8..8a5e8e24b7 100644--- a/apps/desktop/src/components/connection/ConnectionDialog.vue+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue@@ -151,7 +151,7 @@ import { resolveVisibleDatabaseSaveAction } from "@/components/sidebar/visibleDaimport { canSaveVisibleDatabaseSelection, connectionUsesVisibleSchemaFilter, filterDatabaseNamesForVisiblePicker, filterSchemaNamesForVisiblePicker, buildDraftVisibleSchemasConnectionId, normalizeVisibleSchemaSelection } from "@/lib/database/visibleDatabases";import { isSchemaAware, isSingleDatabase, supportsDataDictionary } from "@/lib/database/databaseFeatureSupport";import { normalizeConnectionScope, normalizeConnectionTimeouts } from "@/lib/connection/connectionSubmitNormalization";-import { databaseConnectionFormKind } from "@/lib/database/databaseDriverManifest";+import { databaseConnectionFormKind, databaseManifestEntry } from "@/lib/database/databaseDriverManifest";import VisibleSchemasDialog from "@/components/sidebar/VisibleSchemasDialog.vue";import CloudflareD1ConnectionFields from "@/components/connection/CloudflareD1ConnectionFields.vue";import SpannerConnectionFields from "@/components/connection/SpannerConnectionFields.vue";@@ -1184,6 +1184,8 @@ const driverProfiles: Record<string, ConnectionProfileDefinition> = {...CONNECTION_PROFILES,...jdbcProductDriverProfiles(),};+const nebulaDriverProfiles = databaseManifestEntry("nebula")?.driverProfiles ?? [];+const nebulaDefaultDriverProfile = nebulaDriverProfiles[0]?.profile ?? "nebula";function profileForConfig(config: ConnectionConfig) {if (config.db_type === "plugin" && config.plugin_id && config.plugin_connection_provider) {@@ -2804,7 +2806,7 @@ function applyProfile(val: string, preserveConnectionFields = false) {const previousDatabaseType = form.value.db_type;selectedType.value = val;form.value.db_type = profile.type;- form.value.driver_profile = val;+ form.value.driver_profile = val === "nebula" ? nebulaDefaultDriverProfile : val;form.value.driver_label = isCustomCompatibleProfile() ? customDriverName.value.trim() || profile.label : profile.label;const preserveMeilisearchConfig = preserveConnectionFields && previousDatabaseType === "meilisearch" && profile.type === "meilisearch";if (profile.type !== "sqlserver" && !preserveMeilisearchConfig) {@@ -3434,6 +3436,12 @@ function switchEtcdApiVersion(profile: "etcd" | "etcd-v2") {resetTestState();}+function switchNebulaDriverProfile(profile: unknown) {+ if (typeof profile !== "string" || !nebulaDriverProfiles.some((entry) => entry.profile === profile)) return;+ form.value.driver_profile = profile;+ resetTestState();+}+function switchH2DriverProfile(profile: "h2" | "h2-v1" | "h2-v2" | "h2-v3" | "h2-custom") {form.value.driver_profile = profile;if (profile === "h2-custom") {@@ -3650,11 +3658,12 @@ const tlsCapableDatabaseTypes = new Set<DatabaseType>(["influxdb","victoriametrics","cassandra",+ "nebula","zookeeper",]);const supportsTlsToggle = computed(() => tlsCapableDatabaseTypes.has(form.value.db_type) || supportsMysqlTlsTab(form.value.db_type, selectedType.value));const supportsCaCertificatePath = computed(() => form.value.db_type === "clickhouse" || form.value.db_type === "victoriametrics");-const supportsGenericUrlParams = computed(() => form.value.db_type !== "manticoresearch" && form.value.db_type !== "hbase");+const supportsGenericUrlParams = computed(() => form.value.db_type !== "manticoresearch" && form.value.db_type !== "hbase" && form.value.db_type !== "nebula");const showGenericUrlParamsHint = computed(() => form.value.db_type === "mysql" || form.value.db_type === "doris" || form.value.db_type === "starrocks");const bareMysqlProfiles = new Set(["doris", "selectdb", "oceanbase"]);const supportsMysqlTlsOptions = computed(() => mysqlTlsOptionsSupported(form.value.db_type, selectedType.value));@@ -4628,6 +4637,9 @@ function connectionConfigForSubmit(id: string, generatedName = "", validatePlugi} else {config = { ...formValueForSubmit(), id } as LegacyConnectionConfig;}+ if (config.db_type === "nebula" && (!config.driver_profile || config.driver_profile === "nebula")) {+ config.driver_profile = nebulaDefaultDriverProfile;+ }config.database_info = undefined;config.database = normalizeStoredConnectionDatabase(config.db_type, config.database);config.note = config.note?.trim() || undefined;@@ -7031,6 +7043,20 @@ function openExternalUrl(url: string) {</button></div>+ <div v-if="form.db_type === 'nebula'" class="grid grid-cols-4 items-center gap-4">+ <Label :class="connectionLabelClass">{{ t("connection.version") }}</Label>+ <div class="col-span-3">+ <Select :model-value="form.driver_profile === 'nebula' ? nebulaDefaultDriverProfile : form.driver_profile" @update:model-value="switchNebulaDriverProfile">+ <SelectTrigger class="w-full">+ <SelectValue />+ </SelectTrigger>+ <SelectContent>+ <SelectItem v-for="profile in nebulaDriverProfiles" :key="profile.profile" :value="profile.profile">{{ profile.label }}</SelectItem>+ </SelectContent>+ </Select>+ </div>+ </div>+<!-- OceanBase mode toggle --><div v-if="selectedType === 'oceanbase'" class="grid grid-cols-4 items-center gap-4"><Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>@@ -9322,7 +9348,7 @@ function openExternalUrl(url: string) {</label></div>- <template v-if="form.db_type === 'etcd' || form.db_type === 'consul' || form.db_type === 'zookeeper' || form.db_type === 'elasticsearch' || form.db_type === 'easysearch'">+ <template v-if="form.db_type === 'etcd' || form.db_type === 'consul' || form.db_type === 'zookeeper' || form.db_type === 'elasticsearch' || form.db_type === 'easysearch' || form.db_type === 'nebula'"><div class="grid grid-cols-4 items-start gap-4"><Label :class="connectionLabelSmallPaddedClass"><span class="inline-flex items-center justify-end gap-1">@@ -9375,7 +9401,7 @@ function openExternalUrl(url: string) {<TooltipContent>{{ t("connection.etcdClientKeyBrowse") }}</TooltipContent></Tooltip></div>- <p class="text-[11px] leading-4 text-muted-foreground">+ <p v-if="form.db_type !== 'nebula'" class="text-[11px] leading-4 text-muted-foreground">{{ t("connection.etcdClientCertHint") }}</p></div>diff --git a/apps/desktop/src/components/editor/EditorSettingsDialog.vue b/apps/desktop/src/components/editor/EditorSettingsDialog.vueindex 72f66daa24..577b5ed367 100644--- a/apps/desktop/src/components/editor/EditorSettingsDialog.vue+++ b/apps/desktop/src/components/editor/EditorSettingsDialog.vue@@ -801,7 +801,7 @@ function sqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles): boolean {function setSqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles, value: boolean) {const dbType = editSqlVariableSyntaxDatabaseType.value;- if (dbType === "neo4j" && key === "named") return;+ if ((dbType === "neo4j" || dbType === "nebula") && key === "named") return;const merged: SqlVariableSyntaxToggles = {...DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES,...editSqlVariableSyntaxOverrides.value[dbType],@@ -7002,7 +7002,7 @@ onUnmounted(() => {<Switch:id="`sql-var-syntax-${key}`":model-value="sqlVariableSyntaxToggle(key)"- :disabled="!editSqlVariableSubstitutionEnabled || (editSqlVariableSyntaxDatabaseType === 'neo4j' && key === 'named')"+ :disabled="!editSqlVariableSubstitutionEnabled || (['neo4j', 'nebula'].includes(editSqlVariableSyntaxDatabaseType) && key === 'named')"class="mt-0.5 shrink-0"@update:model-value="(value) => setSqlVariableSyntaxToggle(key, value as boolean)"/>diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vueindex fd847bcdf8..bbb76f1213 100644--- a/apps/desktop/src/components/grid/DataGrid.vue+++ b/apps/desktop/src/components/grid/DataGrid.vue@@ -750,7 +750,7 @@ const resolvedDatabaseType = computed(() => props.databaseType ?? effectiveDatab// editor and clipboard path must decode it whenever MongoDB values are on screen.const usesMongoDocumentGridValues = computed(() => props.mongoCollectionGrid === true || resolvedDatabaseType.value === "mongodb");const isResultsContext = computed(() => props.context === "results");-const canShowWhereSearch = computed(() => !!props.onExecuteSql && !isResultsContext.value && resolvedDatabaseType.value !== "victoriametrics");+const canShowWhereSearch = computed(() => !!props.onExecuteSql && !isResultsContext.value && resolvedDatabaseType.value !== "victoriametrics" && resolvedDatabaseType.value !== "nebula");const canUseWhereSearch = computed(() => !!props.tableMeta && canShowWhereSearch.value);const canUseServerColumnFilter = computed(() => canUseWhereSearch.value && !!props.connectionId && !!props.tableMeta);const tableStructureCapabilities = computed(() => getTableStructureCapabilities(resolvedDatabaseType.value, resolvedConnectionConfig.value?.db_type));diff --git a/apps/desktop/src/components/icons/DatabaseIcon.vue b/apps/desktop/src/components/icons/DatabaseIcon.vueindex facd61304b..6828f3e411 100644--- a/apps/desktop/src/components/icons/DatabaseIcon.vue+++ b/apps/desktop/src/components/icons/DatabaseIcon.vue@@ -87,6 +87,7 @@ const assetIcons: Record<string, string> = {starrocks: "starrocks",redshift: "redshift",neo4j: "neo4j",+ nebula: "nebula.png",informix: "informix",databricks: "databricks",saphana: "saphana",diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vueindex 5854d37a4c..db43210536 100644--- a/apps/desktop/src/components/objects/ObjectBrowser.vue+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue@@ -310,14 +310,12 @@ const effectiveDatabaseType = computed(() => effectiveDatabaseTypeForConnection(const isGaussdbM = computed(() => effectiveDatabaseType.value === "gaussdb" && props.connection.driver_profile?.toLowerCase() === "gaussdb-m");const isVictoriaMetrics = computed(() => effectiveDatabaseType.value === "victoriametrics");const isMongodb = computed(() => props.connection.db_type === "mongodb");-// Victoria Metrics reports series instead of rows and has no byte size to show;-// every other engine (MongoDB collections included, via `collStats`) fills both-// the row and size columns.-const supportsObjectSizeStats = computed(() => !isVictoriaMetrics.value);+// Neither VictoriaMetrics series nor NebulaGraph tag/edge metadata has table byte-size stats.+const supportsObjectSizeStats = computed(() => !isVictoriaMetrics.value && effectiveDatabaseType.value !== "nebula");// The batch table toolbar (export/copy/truncate/empty/drop selected) is SQL-only:// MongoDB collections are not dropped or truncated through it.-const supportsBatchTableActions = computed(() => !isVictoriaMetrics.value && !isMongodb.value);-const showTableStatistics = computed(() => objectFilter.value === "all" || objectFilter.value === "tables");+const supportsBatchTableActions = computed(() => !isVictoriaMetrics.value && !isMongodb.value && effectiveDatabaseType.value !== "nebula");+const showTableStatistics = computed(() => effectiveDatabaseType.value !== "nebula" && (objectFilter.value === "all" || objectFilter.value === "tables"));const showObjectRowStats = computed(() => showTableStatistics.value);const showObjectSizeStats = computed(() => supportsObjectSizeStats.value && showTableStatistics.value);const objectRowsLabel = computed(() => t(isVictoriaMetrics.value ? "objects.series" : "objects.rows"));@@ -617,7 +615,7 @@ watch(},);-const showCheckboxColumn = computed(() => settingsStore.editorSettings.objectBrowserShowCheckbox || selectedTableCount.value > 0);+const showCheckboxColumn = computed(() => supportsBatchTableActions.value && (settingsStore.editorSettings.objectBrowserShowCheckbox || selectedTableCount.value > 0));function toggleCheckboxColumn() {const next = !settingsStore.editorSettings.objectBrowserShowCheckbox;@@ -2576,7 +2574,7 @@ async function copySelectedTablesToClipboard() {}function canPasteTableClipboard(): boolean {- return !isVictoriaMetrics.value && !isMongodb.value && tableClipboardMatchesTarget(normalizedObjectBrowserTableClipboardEntries(), pasteTableTargetContext());+ return supportsBatchTableActions.value && tableClipboardMatchesTarget(normalizedObjectBrowserTableClipboardEntries(), pasteTableTargetContext());}function normalizedObjectBrowserTableClipboardEntries() {@@ -2668,7 +2666,7 @@ function openPasteTableDialog() {}function onObjectBrowserKeydown(event: KeyboardEvent) {- if (event.defaultPrevented) return;+ if (event.defaultPrevented || !supportsBatchTableActions.value) return;if (eventTargetAllowsAppClipboardShortcut(event, "c")) {if (selectedTableCount.value === 0) return;event.preventDefault();@@ -3462,6 +3460,14 @@ function selectedBatchTableCountLabel(key: "batchDrop" | "batchTruncate" | "batc}function getTableMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {+ if (effectiveDatabaseType.value === "nebula") {+ return [+ { label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },+ { label: t("contextMenu.viewDdl"), action: () => openTableInfo(item, "ddl"), icon: FileCode },+ { label: "", separator: true },+ { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },+ ];+ }if (isVictoriaMetrics.value) {return [{ label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },@@ -3530,6 +3536,14 @@ function getTableMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {}function getViewMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {+ if (effectiveDatabaseType.value === "nebula") {+ return [+ { label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },+ { label: t("contextMenu.viewDdl"), action: () => openTableInfo(item, "ddl"), icon: ScrollText },+ { label: "", separator: true },+ { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },+ ];+ }return [{ label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },{ label: t("contextMenu.editView"), action: () => openSource(item), icon: PencilLine },@@ -3709,7 +3723,7 @@ function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {<LayoutGrid class="h-3.5 w-3.5" /></button></div>- <Button v-if="showInlineCheckboxToggle" variant="ghost" size="icon" class="h-7 w-7" :class="{ 'text-primary': settingsStore.editorSettings.objectBrowserShowCheckbox }" :title="t('objects.toggleCheckbox')" @click="toggleCheckboxColumn">+ <Button v-if="showInlineCheckboxToggle && supportsBatchTableActions" variant="ghost" size="icon" class="h-7 w-7" :class="{ 'text-primary': settingsStore.editorSettings.objectBrowserShowCheckbox }" :title="t('objects.toggleCheckbox')" @click="toggleCheckboxColumn"><CheckSquare v-if="settingsStore.editorSettings.objectBrowserShowCheckbox" class="h-3.5 w-3.5" /><Square v-else class="h-3.5 w-3.5" /></Button>@@ -3747,14 +3761,14 @@ function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {<LayoutGrid class="h-3.5 w-3.5" />{{ t("objects.viewGrid") }}</DropdownMenuItem>- <DropdownMenuCheckboxItem :model-value="settingsStore.editorSettings.objectBrowserShowCheckbox" @select.prevent @update:model-value="toggleCheckboxColumn()">{{ t("objects.toggleCheckbox") }}</DropdownMenuCheckboxItem>+ <DropdownMenuCheckboxItem v-if="supportsBatchTableActions" :model-value="settingsStore.editorSettings.objectBrowserShowCheckbox" @select.prevent @update:model-value="toggleCheckboxColumn()">{{ t("objects.toggleCheckbox") }}</DropdownMenuCheckboxItem><template v-if="showObjectFilter && toolbarTier >= 2"><DropdownMenuSeparator /><DropdownMenuCheckboxItem v-for="filter in objectFilters" :key="filter" :model-value="objectFilter === filter" @select.prevent @update:model-value="selectObjectFilter(filter)">{{ filterLabel(filter) }}</DropdownMenuCheckboxItem></template></ToolbarOverflowMenu></div>- <div v-if="selectedTableCount > 0" class="flex h-9 shrink-0 items-center gap-2 overflow-x-auto border-b bg-muted/30 px-3 text-xs">+ <div v-if="selectedTableCount > 0 && supportsBatchTableActions" class="flex h-9 shrink-0 items-center gap-2 overflow-x-auto border-b bg-muted/30 px-3 text-xs"><div class="min-w-0 flex-1 truncate text-muted-foreground">{{ t("objects.selectedTables", { count: selectedTableCount }) }}</div>diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.tableCopyClipboard.component.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.tableCopyClipboard.component.spec.tsindex ee4e98f521..c617c88e7a 100644--- a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.tableCopyClipboard.component.spec.ts+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.tableCopyClipboard.component.spec.ts@@ -93,6 +93,7 @@ const mountedApps: Array<{ app: App; host: HTMLElement }> = [];beforeEach(() => {vi.clearAllMocks();+ connection.db_type = "mysql";mocks.store.treeClipboard = null;mocks.listObjects.mockResolvedValue([{ name: "orders", object_type: "TABLE" },@@ -154,4 +155,18 @@ describe("ObjectBrowser table copy", () => {await vi.waitFor(() => expect(mocks.toast).toHaveBeenCalledWith("grid.copyFailed", 5000));expect(mocks.toast).not.toHaveBeenCalledWith("contextMenu.pasteTableClipboardUpdated", 2000);});++ it("does not expose relational table copy or batch actions for NebulaGraph", async () => {+ connection.db_type = "nebula";+ const host = await mountBrowser();+ rowFor(host, "orders").dispatchEvent(new MouseEvent("click", { bubbles: true, ctrlKey: true }));+ await nextTick();++ expect(host.textContent).not.toContain("objects.exportSelected");+ expect(host.textContent).not.toContain("objects.dropSelected");+ expect(host.querySelector('[title="objects.toggleCheckbox"]')).toBeNull();+ host.querySelector<HTMLElement>("[data-object-browser-root]")!.dispatchEvent(new KeyboardEvent("keydown", { key: "c", ctrlKey: true, bubbles: true }));+ expect(mocks.copyToClipboard).not.toHaveBeenCalled();+ expect(mocks.store.treeClipboard).toBeNull();+ });});diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vueindex 6356c51e1c..6f9b35cb03 100644--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue@@ -2787,6 +2787,7 @@ function requestDropTableChildObject() {}function canDropTreeNode(node: TreeNode): boolean {+ if (databaseTypeForNode(node) === "nebula") return false;if (isSqlServerLinkedNode(node)) return false;if (node.type === "table") return !!node.connectionId && !!node.database;if (node.type === "view" || node.type === "materialized_view" || node.type === "procedure" || node.type === "function" || node.type === "event") {@@ -3129,6 +3130,7 @@ function requestDropSelectedNodes(): boolean {}function requestDropSelectedNode(): boolean {+ if (currentDatabaseType() === "nebula") return false;if (activeNode.value.type === "table") {dropTable();return true;@@ -4753,7 +4755,7 @@ const canOpenSqlFileExecution = computed(() => {const canExportAllDatabases = computed(() => {if (activeNode.value.type !== "connection" || !activeNode.value.connectionId) return false;const dbType = connectionStore.getConfig(activeNode.value.connectionId)?.db_type;- return !["redis", "mongodb", "dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "plugin", "salesforce"].includes(dbType || "");+ return !["redis", "mongodb", "dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "plugin", "salesforce", "nebula"].includes(dbType || "");});const canOpenScheduledBackups = computed(() => {@@ -5860,6 +5862,19 @@ function buildDatabaseSidebarMenu(context: SidebarMenuFactoryContext): boolean {});return true;}+ if (currentDatabaseType() === "nebula" && node.type === "database") {+ if (canCloseDatabaseConnection.value) items.push({ label: t("contextMenu.closeDatabaseConnection"), action: closeDatabaseConnection, icon: Unplug });+ items.push(copyNameMenuItem());+ items.push({ label: "", separator: true });+ if (canOpenObjectBrowser.value) items.push({ label: t("contextMenu.openObjectBrowser"), action: openObjectBrowser, icon: TableProperties });+ items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });+ const sqlHistoryMenu = savedSqlHistorySubmenu();+ if (sqlHistoryMenu) items.push(sqlHistoryMenu);+ items.push({ label: isNodeDefaultDatabase.value ? t("contextMenu.clearDefaultDatabase") : t("contextMenu.setDefaultDatabase"), action: isNodeDefaultDatabase.value ? clearNodeDefaultDatabase : setNodeAsDefaultDatabase, icon: Database });+ items.push({ label: "", separator: true });+ items.push({ label: t("contextMenu.refreshChildren"), action: refresh, icon: RefreshCw, shortcut: shortcutRefresh });+ return true;+ }if (canCloseDatabaseConnection.value) {items.unshift({ label: "", separator: true });items.unshift({ label: t("contextMenu.closeDatabaseConnection"), action: closeDatabaseConnection, icon: Unplug });@@ -6266,6 +6281,20 @@ function buildObjectSidebarMenu(context: SidebarMenuFactoryContext): boolean {appendPluginTableMenuItems(items, node);return true;}+ if (currentDatabaseType() === "nebula") {+ items.push(copyNameMenuItem());+ items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });+ items.push({ label: "", separator: true });+ items.push({ label: t("contextMenu.viewData"), action: openDataImmediately, icon: TableProperties });+ items.push({ label: t("contextMenu.openInNewDataTab"), action: openDataInNewTabImmediately, icon: CopyPlus, shortcut: shortcutOpenDataInNewTab.value });+ items.push({ label: t("contextMenu.viewDdl"), action: openDdl, icon: FileCode });+ const sqlHistoryMenu = savedSqlHistorySubmenu();+ if (sqlHistoryMenu) items.push(sqlHistoryMenu);+ items.push({ label: "", separator: true });+ items.push({ label: t("contextMenu.refreshChildren"), action: refresh, icon: RefreshCw, shortcut: shortcutRefresh });+ appendPluginTableMenuItems(items, node);+ return true;+ }const destructiveActions: ContextMenuItem[] = [];items.push(copyNameMenuItem());items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });@@ -6618,7 +6647,7 @@ function buildObjectGroupSidebarMenu(context: SidebarMenuFactoryContext): booleaconst mysqlObjectTemplate = node.connectionId ? mysqlObjectTemplateForGroup(connectionStore.getConfig(node.connectionId), node) : null;const hasMongoCreateIndexAction = node.type === "group-indexes" && canCreateMongoIndex.value;const hasMongoDropAllIndexesAction = node.type === "group-indexes" && canDropAllMongoIndexes.value;- const hasGroupAction = (node.type === "group-tables" && canCreateTable.value) || (node.type === "group-views" && !!node.connectionId && !!node.database) || !!mysqlObjectTemplate || hasMongoCreateIndexAction || hasMongoDropAllIndexesAction;+ const hasGroupAction = (node.type === "group-tables" && canCreateTable.value) || (node.type === "group-views" && !!node.connectionId && !!node.database && currentDatabaseType() !== "nebula") || !!mysqlObjectTemplate || hasMongoCreateIndexAction || hasMongoDropAllIndexesAction;const canLoadAllObjectGroup = node.type === "group-tables" || node.type === "group-dolt-system-tables" || node.type === "group-views" || node.type === "group-materialized-views";if (node.type === "group-tables" && canCreateTable.value) {items.push({ label: t("contextMenu.createTable"), action: createTable, icon: Plus });@@ -6629,7 +6658,7 @@ function buildObjectGroupSidebarMenu(context: SidebarMenuFactoryContext): booleaitems.push({ label: t("contextMenu.pasteTable"), action: openPasteTableDialog, icon: Clipboard });}}- if (node.type === "group-views" && node.connectionId && node.database) {+ if (node.type === "group-views" && node.connectionId && node.database && currentDatabaseType() !== "nebula") {items.push({ label: t("contextMenu.createView"), action: createView, icon: Plus });}if (node.type === "group-events" && node.connectionId && node.database) {diff --git a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.nebulaContextMenu.spec.ts b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.nebulaContextMenu.spec.tsnew file mode 100644index 0000000000..473c576ac8--- /dev/null+++ b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.nebulaContextMenu.spec.ts@@ -0,0 +1,80 @@+// @vitest-environment happy-dom+import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";+import { createPinia, setActivePinia } from "pinia";+import { afterEach, describe, expect, it, vi } from "vitest";+import i18n from "@/i18n";+import type { ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";+import type { TreeNode } from "@/types/database";++vi.mock("@/lib/backend/api", async (importOriginal) => {+ const actual = await importOriginal<typeof import("@/lib/backend/api")>();+ return { ...actual, listPlugins: vi.fn().mockResolvedValue([]) };+});++import SidebarTreeRuntimeHost from "@/components/sidebar/SidebarTreeRuntimeHost.vue";+import { useConnectionStore } from "@/stores/connectionStore";++const connection = { id: "nebula-1", name: "NebulaGraph", db_type: "nebula", driver_profile: "nebula", host: "localhost", port: 9669, username: "root", password: "" };+const node = (type: TreeNode["type"], label: string): TreeNode => ({ id: `nebula-1:space:${type}:${label}`, type, label, connectionId: connection.id, database: "space", tableName: label });+const mountedApps: App<Element>[] = [];+const labels = (items: ContextMenuItem[]): string[] => items.flatMap((item) => [...(item.label ? [item.label] : []), ...(item.children ? labels(item.children) : [])]);+const tr = (key: string) => i18n.global.t(key);++async function mountHost() {+ const pinia = createPinia();+ setActivePinia(pinia);+ useConnectionStore().connections = [connection];+ const host = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);+ const root = defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: node("connection", connection.name), depth: 0 }) });+ const container = document.createElement("div");+ document.body.appendChild(container);+ const app = createApp(root);+ app.use(pinia);+ app.use(i18n);+ app.mount(container);+ mountedApps.push(app);+ await nextTick();+ await new Promise((resolve) => setTimeout(resolve, 0));+ await nextTick();+ return host.value as { buildContextMenu(node: TreeNode): ContextMenuItem[] };+}++describe("NebulaGraph sidebar context menus", () => {+ afterEach(() => {+ for (const app of mountedApps.splice(0)) app.unmount();+ document.body.innerHTML = "";+ });++ it("keeps space browsing and queries without relational database operations", async () => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node("database", "space")));+ expect(items).toEqual(expect.arrayContaining([tr("contextMenu.copyName"), tr("contextMenu.newQuery"), tr("contextMenu.openObjectBrowser"), tr("contextMenu.refreshChildren")]));+ for (const key of ["transfer.dataTransfer", "diff.title", "dataCompare.title", "contextMenu.exportDatabase", "dataDictionary.title", "sqlFile.title"]) {+ expect(items).not.toContain(tr(key));+ }+ });++ it.each(["table", "view"] as const)("keeps %s reads and DDL without SQL table mutations", async (type) => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node(type, type === "table" ? "person" : "knows")));+ expect(items).toEqual(expect.arrayContaining([tr("contextMenu.copyName"), tr("contextMenu.newQuery"), tr("contextMenu.viewData"), tr("contextMenu.viewDdl"), tr("contextMenu.refreshChildren")]));+ for (const key of ["contextMenu.generateSql", "contextMenu.exportDatabase", "contextMenu.exportData", "contextMenu.editView", "contextMenu.dropView", "contextMenu.dropTable", "contextMenu.emptyTable", "contextMenu.duplicateStructure", "dataCompare.title"]) {+ expect(items).not.toContain(tr(key));+ }+ });++ it("does not offer SQL view creation on the edge group", async () => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node("group-views", "Edges")));+ expect(items).toContain(tr("contextMenu.refreshChildren"));+ expect(items).not.toContain(tr("contextMenu.createView"));+ });++ it("does not offer SQL files or all-database export on the connection", async () => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node("connection", connection.name)));+ expect(items).toContain(tr("contextMenu.newQuery"));+ expect(items).not.toContain(tr("sqlFile.title"));+ expect(items).not.toContain(tr("contextMenu.exportAllDatabases"));+ });+});diff --git a/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts b/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.tsindex 64e9ad020b..3f397b2021 100644--- a/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts+++ b/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts@@ -425,6 +425,40 @@ describe("useSidebarDataOpenRuntime", () => {});});+ it("waits for NebulaGraph properties before building the first table query", async () => {+ mocks.databaseType = "nebula";+ let releaseMetadata: () => void = () => {};+ const gate = new Promise<void>((resolve) => {+ releaseMetadata = resolve;+ });+ mocks.loadTableMetadata.mockImplementation(async () => {+ await gate;+ return {+ metadata: {+ schema: "public",+ tableName: "users",+ tableType: "TABLE",+ database: "app",+ columns: [{ name: "name", data_type: "string", is_nullable: true, column_default: null, is_primary_key: false, extra: null }],+ indexes: [],+ primaryKeys: [],+ cachedAt: Date.now(),+ },+ cacheStatus: "miss",+ ageMs: 0,+ };+ });++ const opening = useSidebarDataOpenRuntime().openData(tableNode);+ await vi.waitFor(() => expect(mocks.loadTableMetadata).toHaveBeenCalled());+ expect(mocks.buildTableSelectSql).not.toHaveBeenCalled();+ releaseMetadata();+ await opening;++ expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ databaseType: "nebula", columns: ["name"] }));+ expect(mocks.callOrder).toEqual(["query"]);+ });+it("keeps Dameng metadata deferred until after the table query", async () => {mocks.databaseType = "dameng";diff --git a/apps/desktop/src/lib/__tests__/connection/connectionUrl.nebula.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionUrl.nebula.spec.tsnew file mode 100644index 0000000000..1b9cb73fc9--- /dev/null+++ b/apps/desktop/src/lib/__tests__/connection/connectionUrl.nebula.spec.ts@@ -0,0 +1,21 @@+import { describe, expect, it } from "vitest";+import { connectionUrlPlaceholder } from "@/lib/connection/connectionPresentation";+import { parseConnectionUrl } from "@/lib/connection/connectionUrl";++describe("NebulaGraph connection URLs", () => {+ it("parses graphd connection details and an optional space", () => {+ expect(parseConnectionUrl("nebula://root:[email protected]:9669/demo")).toMatchObject({+ dbType: "nebula",+ driverProfile: "nebula",+ host: "graphd.example.com",+ port: 9669,+ username: "root",+ password: "secret",+ database: "demo",+ });+ });++ it("shows a NebulaGraph-specific placeholder", () => {+ expect(connectionUrlPlaceholder("nebula")).toBe("nebula://root:password@graphd:9669/space");+ });+});diff --git a/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.tsindex 3b59c33f87..9b7ab7a11e 100644--- a/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts+++ b/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts@@ -37,6 +37,10 @@ describe("databaseDriverManifest", () => {});});+ it("offers only the supported NebulaGraph 3.x profile", () => {+ expect(databaseManifestEntry("nebula")?.driverProfiles).toEqual([{ profile: "nebula-v3", agentKey: "nebula", label: "NebulaGraph 3.x", storeVisible: false }]);+ });+it("routes only specialized connection forms explicitly", () => {expect(databaseConnectionFormKind("mysql")).toBe("standard");expect(databaseConnectionFormKind("jdbc")).toBe("jdbc");diff --git a/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.tsindex 666932ceaa..89b746b07e 100644--- a/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts+++ b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts@@ -46,6 +46,15 @@ describe("extractSqlParameters", () => {expect(extractSqlParameters("MATCH (p:Person {name:${name}}) RETURN p", options)).toEqual(["name"]);});+ it("keeps NebulaGraph tags and edge types intact in nGQL", () => {+ const ngql = 'MATCH (p:Person)-[:WORK_IN]->(c:Company{name:"星云科技"}) RETURN p.Person.name LIMIT 10';+ const options = { databaseType: "nebula" as const };+ expect(extractSqlParameterDescriptors(ngql, options)).toEqual([]);+ expect(substituteSqlParameters(ngql, {}, options)).toBe(ngql);+ expect(extractSqlParameters("MATCH (p:Person {name:${name}}) RETURN p LIMIT 10", options)).toEqual(["name"]);+ expect(extractSqlParameters("select :customer_id", { databaseType: "mysql" })).toEqual(["customer_id"]);+ });+it("extracts unique template parameters in order", () => {const sql = "select * from t where pt_dt between ${start_date} and ${end_date} or pt_dt = ${start_date}";expect(extractSqlParameters(sql)).toEqual(["start_date", "end_date"]);diff --git a/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.tsindex c0944c726d..e30fef0017 100644--- a/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts+++ b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts@@ -19,6 +19,13 @@ describe("resolveSqlVariableSyntaxToggles", () => {expect(resolveSqlVariableSyntaxToggles({ neo4j: { shell: false } }, "neo4j")).toEqual({ ...toggles, shell: false });});+ it("disables SQL named placeholders for NebulaGraph", () => {+ const toggles = resolveSqlVariableSyntaxToggles(undefined, "nebula");+ expect(toggles).toEqual({ ...DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, named: false });+ expect(enabledSqlParameterSyntaxes(toggles)).not.toContain("named");+ expect(resolveSqlVariableSyntaxToggles(undefined, "mysql").named).toBe(true);+ });+it("enables every syntax when the database type is unknown", () => {expect(resolveSqlVariableSyntaxToggles({ mysql: { shell: false } }, undefined)).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);});diff --git a/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.tsindex 17848bb00b..c68b3f89cf 100644--- a/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts+++ b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts@@ -322,6 +322,7 @@ describe("quoteTableIdentifier", () => {expect(requiresEagerTableMetadataForDataOpen("salesforce")).toBe(true);expect(requiresEagerTableMetadataForDataOpen("mysql")).toBe(true);expect(requiresEagerTableMetadataForDataOpen("postgres")).toBe(true);+ expect(requiresEagerTableMetadataForDataOpen("nebula")).toBe(true);// Drivers whose preview works from `SELECT *` keep loading metadata lazily.expect(requiresEagerTableMetadataForDataOpen("sqlite")).toBe(false);expect(requiresEagerTableMetadataForDataOpen(undefined)).toBe(false);diff --git a/apps/desktop/src/lib/connection/__tests__/agentDriverInstallHint.spec.ts b/apps/desktop/src/lib/connection/__tests__/agentDriverInstallHint.spec.tsindex 3e871932f7..cd491b0f82 100644--- a/apps/desktop/src/lib/connection/__tests__/agentDriverInstallHint.spec.ts+++ b/apps/desktop/src/lib/connection/__tests__/agentDriverInstallHint.spec.ts@@ -38,6 +38,15 @@ describe("Transwarp driver installation", () => {});});+describe("NebulaGraph driver installation", () => {+ it("routes the v3 profile and legacy connections to the same Agent package", () => {+ for (const profile of [undefined, "nebula", "nebula-v3"]) {+ expect(agentDriverInstallKey("nebula", profile)).toBe("nebula");+ expect(showAgentDriverInstallHint("nebula", [{ db_type: "nebula", installed: true }], profile)).toBe(false);+ }+ });+});+describe("shouldApplyDriverStoreFocus", () => {it("applies when the driver first appears after a list load", () => {expect(shouldApplyDriverStoreFocus(null, "driver:mysql", false)).toBe(true);diff --git a/apps/desktop/src/lib/connection/__tests__/driverCategoryDefinitions.spec.ts b/apps/desktop/src/lib/connection/__tests__/driverCategoryDefinitions.spec.tsindex 623776fe04..ee7c946ac7 100644--- a/apps/desktop/src/lib/connection/__tests__/driverCategoryDefinitions.spec.ts+++ b/apps/desktop/src/lib/connection/__tests__/driverCategoryDefinitions.spec.ts@@ -125,6 +125,7 @@ describe("AGENT_DRIVER_CATEGORY_MAP integrity", () => {"mongodb",// graph_ai"neo4j",+ "nebula",// timeseries"influxdb","iotdb",diff --git a/apps/desktop/src/lib/connection/agentDriverInstallHint.ts b/apps/desktop/src/lib/connection/agentDriverInstallHint.tsindex cd5b0664f9..ea9e4ea153 100644--- a/apps/desktop/src/lib/connection/agentDriverInstallHint.ts+++ b/apps/desktop/src/lib/connection/agentDriverInstallHint.ts@@ -1,5 +1,6 @@import type { DatabaseType } from "@/types/database";import { supportsDriverManagement } from "@/lib/database/databaseCapabilities";+import { databaseManifestEntry } from "@/lib/database/databaseDriverManifest";export interface AgentDriverInstallState {db_type: string;@@ -38,6 +39,10 @@ export function agentDriverInstallKey(dbType: DatabaseType | undefined, driverPrif (dbType === "oracle") return "oracle";if (dbType === "h2") return "h2";if (dbType === "transwarp") return "transwarp";+ if (dbType === "nebula") {+ const entry = databaseManifestEntry(dbType);+ return entry?.driverProfiles?.find((profile) => profile.profile === driverProfile)?.agentKey ?? entry?.agentKey;+ }if (dbType === "mongodb") return "mongodb";if (dbType === "dameng") return "dameng";if (dbType === "gbase") return driverProfile === "gbase8s" ? "gbase8s" : "gbase8a";diff --git a/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts b/apps/desktop/src/lib/connection/connectionAttemptTimeout.tsindex a2e999d7b0..01596de674 100644--- a/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts+++ b/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts@@ -40,6 +40,7 @@ const DRIVER_STARTUP_FLOOR_TYPES = new Set<DatabaseType>(["db2","informix","neo4j",+ "nebula","cassandra","bigquery","spanner",diff --git a/apps/desktop/src/lib/connection/connectionPresentation.ts b/apps/desktop/src/lib/connection/connectionPresentation.tsindex 69c39cd9ca..7e28de5dc8 100644--- a/apps/desktop/src/lib/connection/connectionPresentation.ts+++ b/apps/desktop/src/lib/connection/connectionPresentation.ts@@ -212,6 +212,9 @@ export function connectionUrlPlaceholder(dbType: DatabaseType, driverProfile?: scase "mongodb":return "mongodb://user:password@host:port/database";+ case "nebula":+ return "nebula://root:password@graphd:9669/space";+case "dynamodb":return "https://dynamodb.us-east-1.amazonaws.com";diff --git a/apps/desktop/src/lib/connection/connectionUrl.ts b/apps/desktop/src/lib/connection/connectionUrl.tsindex 48f33b1065..77a8a19a45 100644--- a/apps/desktop/src/lib/connection/connectionUrl.ts+++ b/apps/desktop/src/lib/connection/connectionUrl.ts@@ -54,6 +54,7 @@ const SCHEME_PROFILES: Record<string, ConnectionProfile> = {"mongodb+srv": { type: "mongodb", profile: "mongodb", label: "MongoDB", defaultPort: 27017 },dynamodb: { type: "dynamodb", profile: "dynamodb", label: "Amazon DynamoDB", defaultPort: 443 },clickhouse: { type: "clickhouse", profile: "clickhouse", label: "ClickHouse", defaultPort: 8123 },+ nebula: { type: "nebula", profile: "nebula", label: "NebulaGraph", defaultPort: 9669 },sqlserver: { type: "sqlserver", profile: "sqlserver", label: "SQL Server", defaultPort: 1433 },mssql: { type: "sqlserver", profile: "sqlserver", label: "SQL Server", defaultPort: 1433 },oracle: { type: "oracle", profile: "oracle", label: "Oracle", defaultPort: 1521 },diff --git a/apps/desktop/src/lib/connection/driver-category-definitions.ts b/apps/desktop/src/lib/connection/driver-category-definitions.tsindex 59538d0ead..b79ba108f9 100644--- a/apps/desktop/src/lib/connection/driver-category-definitions.ts+++ b/apps/desktop/src/lib/connection/driver-category-definitions.ts@@ -46,6 +46,7 @@ export const AGENT_DRIVER_CATEGORY_MAP: Readonly<Record<string, DriverCategoryKeignite3: "analytics",mongodb: "document",neo4j: "graph_ai",+ nebula: "graph_ai","oceanbase-oracle": "domestic",oracle: "sql",oscar: "domestic",diff --git a/apps/desktop/src/lib/database/__tests__/dataDictionarySupport.spec.ts b/apps/desktop/src/lib/database/__tests__/dataDictionarySupport.spec.tsindex 6b7998a1d8..7386ecfc29 100644--- a/apps/desktop/src/lib/database/__tests__/dataDictionarySupport.spec.ts+++ b/apps/desktop/src/lib/database/__tests__/dataDictionarySupport.spec.ts@@ -12,6 +12,7 @@ describe("supportsDataDictionary", () => {it("is hidden for engines that cannot list table metadata", () => {expect(supportsDataDictionary("redis")).toBe(false);+ expect(supportsDataDictionary("nebula")).toBe(false);expect(supportsDataDictionary("plugin")).toBe(false);});});diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.tsindex 48806fbd06..3891a43042 100644--- a/apps/desktop/src/lib/database/databaseFeatureSupport.ts+++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts@@ -147,7 +147,7 @@ export function supportsQueryExecution(dbType?: DatabaseType): boolean {* that hierarchy, so they must not be offered by sidebar "Add to AI" actions.*/export function supportsAiAssistantContext(dbType?: DatabaseType): boolean {- return supportsQueryExecution(dbType) && !usesConnectionOnlyQueryTarget(dbType);+ return supportsQueryExecution(dbType) && !usesConnectionOnlyQueryTarget(dbType) && dbType !== "nebula";}export function supportsConnectionScopedQueryExecution(dbType?: DatabaseType): boolean {@@ -182,7 +182,7 @@ export function supportsSqlFileExecution(dbType?: DatabaseType): boolean {return supportsDatabaseFeature(dbType, "sqlFileExecution");}-const NON_SQL_IN_LIST_PASTE_TYPES = new Set<DatabaseType>(["neo4j"]);+const NON_SQL_IN_LIST_PASTE_TYPES = new Set<DatabaseType>(["neo4j", "nebula"]);export function supportsSqlInListPaste(dbType?: DatabaseType): boolean {if (!dbType) return true;@@ -200,7 +200,7 @@ export function supportsSchemaDiagram(dbType?: DatabaseType): boolean {/** Relational engines that can list tables and columns. Independent of diagram support. */export function supportsDataDictionary(dbType?: DatabaseType): boolean {- return supportsDatabaseFeature(dbType, "metadataBrowse");+ return dbType !== "nebula" && supportsDatabaseFeature(dbType, "metadataBrowse");}export function supportsDatabaseSearch(dbType?: DatabaseType): boolean {@@ -256,7 +256,19 @@ export function supportsObjectBrowserTreeNode(dbType: DatabaseType | undefined,export function supportsTableTruncate(dbType?: DatabaseType): boolean {return (- !!dbType && dbType !== "impala" && dbType !== "sqlite" && dbType !== "rqlite" && dbType !== "turso" && dbType !== "cloudflare-d1" && dbType !== "duckdb" && dbType !== "influxdb" && dbType !== "influxdb3" && dbType !== "victoriametrics" && dbType !== "manticoresearch" && dbType !== "salesforce"+ !!dbType &&+ dbType !== "impala" &&+ dbType !== "sqlite" &&+ dbType !== "rqlite" &&+ dbType !== "turso" &&+ dbType !== "cloudflare-d1" &&+ dbType !== "duckdb" &&+ dbType !== "influxdb" &&+ dbType !== "influxdb3" &&+ dbType !== "victoriametrics" &&+ dbType !== "manticoresearch" &&+ dbType !== "salesforce" &&+ dbType !== "nebula");}diff --git a/apps/desktop/src/lib/database/databaseNamespaceCreation.ts b/apps/desktop/src/lib/database/databaseNamespaceCreation.tsindex ddcc6f14a5..bea2dafcea 100644--- a/apps/desktop/src/lib/database/databaseNamespaceCreation.ts+++ b/apps/desktop/src/lib/database/databaseNamespaceCreation.ts@@ -77,6 +77,7 @@ export const DATABASE_NAMESPACE_CREATION_MATRIX = {db2: { database: "schema" },informix: { connection: "database" },neo4j: { deferred: "database creation depends on edition/admin privileges" },+ nebula: { deferred: "space creation requires partition, replica and VID type options" },cassandra: { deferred: "keyspace creation requires replication options" },bigquery: { deferred: "dataset creation needs project/location options" },spanner: { deferred: "database creation requires the Cloud Spanner Admin API" },diff --git a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts b/apps/desktop/src/lib/database/databaseObjectCapabilities.tsindex aaff3ab1ca..3ae0e51a64 100644--- a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts+++ b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts@@ -97,6 +97,7 @@ const DATABASE_TYPE_OBJECTS = new Map<DatabaseType, SidebarObjectKind[]>([["tdengine", TABLE_VIEW_OBJECTS],["iotdb", TABLE_VIEW_OBJECTS],["neo4j", TABLE_VIEW_OBJECTS],+ ["nebula", TABLE_VIEW_OBJECTS],// others["influxdb", ["TABLE"]],["influxdb3", ["TABLE"]],diff --git a/apps/desktop/src/lib/database/databasePropertyEditing.ts b/apps/desktop/src/lib/database/databasePropertyEditing.tsindex f0a7f45fcb..42228cc2be 100644--- a/apps/desktop/src/lib/database/databasePropertyEditing.ts+++ b/apps/desktop/src/lib/database/databasePropertyEditing.ts@@ -78,6 +78,7 @@ export const DATABASE_PROPERTY_EDITING_MATRIX = {db2: { deferred: "schema properties need product-specific handling" },informix: { deferred: "schema properties need product-specific handling" },neo4j: { deferred: "database properties depend on edition/admin privileges" },+ nebula: { deferred: "space properties require NebulaGraph-specific administration" },cassandra: { deferred: "keyspace properties require replication option handling" },bigquery: { deferred: "dataset properties need project/location-specific handling" },spanner: { deferred: "database/schema properties are Cloud Spanner Admin API operations" },diff --git a/apps/desktop/src/lib/sql/newQueryContext.ts b/apps/desktop/src/lib/sql/newQueryContext.tsindex e3c5aa237e..c85b88b7be 100644--- a/apps/desktop/src/lib/sql/newQueryContext.ts+++ b/apps/desktop/src/lib/sql/newQueryContext.ts@@ -98,7 +98,7 @@ export interface ResolveNewQueryInitialSqlInput extends ResolveNewQueryTableInpu// Database types whose "table" view does not use standard SQL `SELECT * FROM <table>`// (e.g. Neo4j uses Cypher). The new-query prefill is skipped for these.-const NEW_QUERY_PREFILL_DISABLED_TYPES: ReadonlySet<DatabaseType | undefined> = new Set<DatabaseType | undefined>(["neo4j"]);+const NEW_QUERY_PREFILL_DISABLED_TYPES: ReadonlySet<DatabaseType | undefined> = new Set<DatabaseType | undefined>(["neo4j", "nebula"]);export function isNewQueryPrefillSupported(databaseType: DatabaseType | undefined): boolean {return !NEW_QUERY_PREFILL_DISABLED_TYPES.has(databaseType);diff --git a/apps/desktop/src/lib/sql/sqlParameters.ts b/apps/desktop/src/lib/sql/sqlParameters.tsindex b2d19da228..0fc9f70791 100644--- a/apps/desktop/src/lib/sql/sqlParameters.ts+++ b/apps/desktop/src/lib/sql/sqlParameters.ts@@ -378,7 +378,7 @@ function findSqlParameterOccurrences(sql: string, options?: SqlParameterOptions)const occurrences: ParameterOccurrence[] = [];const databaseType = options?.databaseType;const nativeSqlServerParameters = collectNativeSqlServerParameters(sql, databaseType);- const supportsNamedParameters = databaseType !== "saphana" && databaseType !== "neo4j";+ const supportsNamedParameters = databaseType !== "saphana" && databaseType !== "neo4j" && databaseType !== "nebula";const enabledSyntaxes = options?.enabledSyntaxes ? new Set(options.enabledSyntaxes) : null;const isSyntaxEnabled = (syntax: SqlParameterSyntax) => !enabledSyntaxes || enabledSyntaxes.has(syntax);const complexTypeFieldSeparators = supportsNamedParameters && isSyntaxEnabled("named") ? collectComplexTypeFieldSeparators(sql, databaseType) : new Set<number>();diff --git a/apps/desktop/src/lib/sql/sqlStatementRanges.ts b/apps/desktop/src/lib/sql/sqlStatementRanges.tsindex 579f615b7f..6afe36f3fc 100644--- a/apps/desktop/src/lib/sql/sqlStatementRanges.ts+++ b/apps/desktop/src/lib/sql/sqlStatementRanges.ts@@ -27,7 +27,7 @@ export function elasticsearchRestRequestRanges(sql: string, databaseType?: Databreturn requests.length > 0 && requests.every((request) => ELASTICSEARCH_REST_REQUEST.test(request.sql)) ? requests : [];}-const NON_SQL_EXECUTION_TARGET_TYPES: ReadonlySet<DatabaseType> = new Set(["mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "neo4j", "victoriametrics", "salesforce"]);+const NON_SQL_EXECUTION_TARGET_TYPES: ReadonlySet<DatabaseType> = new Set(["mongodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "neo4j", "nebula", "victoriametrics", "salesforce"]);export function supportsExecutionTargetPicker(databaseType?: DatabaseType): boolean {return !!databaseType && (databaseType === "redis" || isHttpJsonRestDatabaseType(databaseType) || !NON_SQL_EXECUTION_TARGET_TYPES.has(databaseType));diff --git a/apps/desktop/src/lib/sql/sqlVariableSyntax.ts b/apps/desktop/src/lib/sql/sqlVariableSyntax.tsindex 8d7b0bf852..c698b6615b 100644--- a/apps/desktop/src/lib/sql/sqlVariableSyntax.ts+++ b/apps/desktop/src/lib/sql/sqlVariableSyntax.ts@@ -72,7 +72,7 @@ export function resolveSqlVariableSyntaxToggles(overrides: SqlVariableSyntaxOverconst partial = dbType ? overrides?.[dbType] : undefined;return {positional: partial?.positional ?? true,- named: dbType === "neo4j" ? false : (partial?.named ?? true),+ named: dbType === "neo4j" || dbType === "nebula" ? false : (partial?.named ?? true),shell: partial?.shell ?? true,mybatis: partial?.mybatis ?? true,sqlserver: partial?.sqlserver ?? true,diff --git a/apps/desktop/src/lib/table/tableSelectSql.ts b/apps/desktop/src/lib/table/tableSelectSql.tsindex f449176ed1..26fdaabf94 100644--- a/apps/desktop/src/lib/table/tableSelectSql.ts+++ b/apps/desktop/src/lib/table/tableSelectSql.ts@@ -447,9 +447,11 @@ export function normalizeWhereInput(whereInput?: string): string {* * Salesforce: SOQL has no `SELECT *`. With no known fields the backend builder* falls back to the `FIELDS(ALL)` selector, which the org only accepts with* `LIMIT 200` or less — awaiting the describe keeps every page size working.+ * * NebulaGraph: without tag/edge properties, the grid can only show a single+ * vertex/edge value instead of separate property columns.*/export function requiresEagerTableMetadataForDataOpen(databaseType: DatabaseType | undefined): boolean {- return databaseType === "mysql" || databaseType === "postgres" || databaseType === "salesforce";+ return databaseType === "mysql" || databaseType === "postgres" || databaseType === "salesforce" || databaseType === "nebula";}export async function buildTableSelectSql(options: BuildTableSelectSqlOptions): Promise<string> {diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.tsindex b6f1a880b4..7f2789f9cd 100644--- a/apps/desktop/src/stores/connectionStore.ts+++ b/apps/desktop/src/stores/connectionStore.ts@@ -1671,6 +1671,7 @@ export const useConnectionStore = defineStore("connection", () => {informix: "Informix",phoenix: "Apache Phoenix",neo4j: "Neo4j",+ nebula: "NebulaGraph",cassandra: "Cassandra",bigquery: "BigQuery",spanner: "Cloud Spanner",diff --git a/apps/desktop/src/types/generated/connectionProfiles.ts b/apps/desktop/src/types/generated/connectionProfiles.tsindex 47fcc32672..640dae6553 100644--- a/apps/desktop/src/types/generated/connectionProfiles.ts+++ b/apps/desktop/src/types/generated/connectionProfiles.ts@@ -96,6 +96,7 @@ export const CONNECTION_PROFILES = {dremio: { type: "jdbc", port: 31010, user: "", label: "Dremio", icon: "dremio" },jdbcx: { type: "jdbc", port: 0, user: "", label: "JDBCX", icon: "jdbcx" },neo4j: { type: "neo4j", port: 7687, user: "neo4j", label: "Neo4j", icon: "neo4j" },+ nebula: { type: "nebula", port: 9669, user: "root", label: "NebulaGraph", icon: "nebula" },cassandra: { type: "cassandra", port: 9042, user: "cassandra", label: "Cassandra", icon: "cassandra" },bigquery: { type: "bigquery", port: 443, user: "", label: "BigQuery", icon: "bigquery", host: "https://www.googleapis.com/bigquery/v2" },spanner: { type: "spanner", port: 443, user: "", label: "Cloud Spanner", icon: "spanner" },@@ -206,6 +207,7 @@ export const CONNECTION_PROFILE_ICONS = {dremio: "dremio",jdbcx: "jdbcx",neo4j: "neo4j",+ nebula: "nebula",cassandra: "cassandra",bigquery: "bigquery",spanner: "spanner",@@ -311,6 +313,7 @@ export const CONNECTION_PICKER_OPTIONS = [{ value: "dremio", label: "Dremio", category: "analytics" },{ value: "jdbcx", label: "JDBCX", category: "sql" },{ value: "neo4j", label: "Neo4j", category: "graph_ai" },+ { value: "nebula", label: "NebulaGraph", category: "graph_ai" },{ value: "cassandra", label: "Cassandra", category: "document" },{ value: "bigquery", label: "BigQuery", category: "analytics" },{ value: "spanner", label: "Cloud Spanner", category: "sql" },diff --git a/apps/desktop/src/types/generated/databaseTypes.ts b/apps/desktop/src/types/generated/databaseTypes.tsindex 1f22ba00f5..6e74e650ca 100644--- a/apps/desktop/src/types/generated/databaseTypes.ts+++ b/apps/desktop/src/types/generated/databaseTypes.ts@@ -59,6 +59,7 @@ export const DATABASE_TYPES = ["db2","informix","neo4j",+ "nebula","cassandra","bigquery","spanner",diff --git a/crates/dbx-cli/src/main.rs b/crates/dbx-cli/src/main.rsindex 282438bc81..bd4e609431 100644--- a/crates/dbx-cli/src/main.rs+++ b/crates/dbx-cli/src/main.rs@@ -66,6 +66,7 @@ const BRIDGE_REQUIRED_TYPES: &[&str] = &["informix","iris","neo4j",+ "nebula","cassandra","bigquery","spanner",diff --git a/crates/dbx-core/assets/database-drivers.manifest.json b/crates/dbx-core/assets/database-drivers.manifest.jsonindex 1108735b1c..76cd91c01c 100644--- a/crates/dbx-core/assets/database-drivers.manifest.json+++ b/crates/dbx-core/assets/database-drivers.manifest.json@@ -2123,6 +2123,46 @@"driverManagement": true}},+ {+ "dbType": "nebula",+ "label": "NebulaGraph",+ "runtimeMode": "agent",+ "mcpMode": "bridge",+ "agentKey": "nebula",+ "driverProfiles": [+ {+ "profile": "nebula-v3",+ "agentKey": "nebula",+ "label": "NebulaGraph 3.x",+ "storeVisible": false+ }+ ],+ "driverStoreVisible": true,+ "driverStoreOrder": 53,+ "singleConnectionPool": false,+ "metadataConnectionScoped": false,+ "skipTcpProbe": true,+ "defaultPort": 9669,+ "supportLevel": "browse",+ "capabilities": {+ "queryExecution": true,+ "metadataBrowse": true,+ "objectBrowser": true,+ "objectSource": true,+ "schemaSearch": false,+ "diagram": false,+ "tableDataEdit": false,+ "tableStructureEdit": false,+ "tableImport": false,+ "dataTransfer": false,+ "sqlFileExecution": false,+ "databaseCreate": false,+ "fieldLineage": false,+ "sqlExplain": false,+ "userAdmin": false,+ "driverManagement": true+ }+ },{"dbType": "cassandra","label": "Apache Cassandra",diff --git a/crates/dbx-core/src/connection/mod.rs b/crates/dbx-core/src/connection/mod.rsindex b83afe393d..712d4bb132 100644--- a/crates/dbx-core/src/connection/mod.rs+++ b/crates/dbx-core/src/connection/mod.rs@@ -330,6 +330,7 @@ macro_rules! agent_connection_pool_database_type {| DatabaseType::Db2| DatabaseType::Informix| DatabaseType::Neo4j+ | DatabaseType::Nebula| DatabaseType::Cassandra| DatabaseType::Bigquery| DatabaseType::Spannerdiff --git a/crates/dbx-driver-agent/src/agent_catalog.rs b/crates/dbx-driver-agent/src/agent_catalog.rsindex 58f4f3d281..e71aa20277 100644--- a/crates/dbx-driver-agent/src/agent_catalog.rs+++ b/crates/dbx-driver-agent/src/agent_catalog.rs@@ -82,6 +82,15 @@ mod tests {assert!(!driver_store_entries().any(|(key, _)| key.starts_with("transwarp-")));}+ #[test]+ fn nebula_v3_profile_reuses_the_legacy_agent_package() {+ for profile in [None, Some("nebula"), Some("nebula-v3")] {+ assert_eq!(agent_key(&DatabaseType::Nebula, profile), Some("nebula"));+ }+ assert_eq!(driver_store_entries().filter(|(key, _)| *key == "nebula").count(), 1);+ assert!(!driver_store_entries().any(|(key, _)| key == "nebula-v3"));+ }+#[test]fn h2_profiles_share_the_same_agent() {assert_eq!(agent_key(&DatabaseType::H2, None), Some("h2"));diff --git a/crates/dbx-sql-core/src/query_execution_sql.rs b/crates/dbx-sql-core/src/query_execution_sql.rsindex fa02ae813c..b6556910a0 100644--- a/crates/dbx-sql-core/src/query_execution_sql.rs+++ b/crates/dbx-sql-core/src/query_execution_sql.rs@@ -268,6 +268,7 @@ pub fn supports_sql_query(database_type: DatabaseType) -> bool {| DatabaseType::InfluxDb3| DatabaseType::VictoriaMetrics| DatabaseType::Neo4j+ | DatabaseType::Nebula| DatabaseType::Etcd)}diff --git a/crates/dbx-sql-data/src/query_result_sql.rs b/crates/dbx-sql-data/src/query_result_sql.rsindex 5dfd51eae1..245126b940 100644--- a/crates/dbx-sql-data/src/query_result_sql.rs+++ b/crates/dbx-sql-data/src/query_result_sql.rs@@ -559,6 +559,7 @@ fn unsupported_pagination_type(database_type: Option<DatabaseType>) -> bool {database_type,Some(DatabaseType::Neo4j+ | DatabaseType::Nebula| DatabaseType::MongoDb| DatabaseType::Redis| DatabaseType::Salesforcediff --git a/crates/dbx-sql-dialect/src/sql_dialect/ddl_profile.rs b/crates/dbx-sql-dialect/src/sql_dialect/ddl_profile.rsindex e5a126e520..cd216dd9a1 100644--- a/crates/dbx-sql-dialect/src/sql_dialect/ddl_profile.rs+++ b/crates/dbx-sql-dialect/src/sql_dialect/ddl_profile.rs@@ -905,7 +905,7 @@ pub fn profile_for(db_type: DatabaseType) -> DdlDialectProfile {// Non-tabular / not applicable for relational CREATE TABLERedis | MongoDb | DynamoDb | Elasticsearch | Easysearch | Solr | Meilisearch | Qdrant | Milvus | Weaviate- | ChromaDb | Neo4j | Cassandra | Etcd | ZooKeeper | Nacos | Consul | InfluxDb3 | VictoriaMetrics+ | ChromaDb | Neo4j | Nebula | Cassandra | Etcd | ZooKeeper | Nacos | Consul | InfluxDb3 | VictoriaMetrics| MessageQueue | Mqtt | Hbase | Salesforce => conservative_ansi(db_type),}}diff --git a/crates/dbx-sql-dialect/src/sql_dialect/identifiers.rs b/crates/dbx-sql-dialect/src/sql_dialect/identifiers.rsindex c139a5e0f9..9b290327c1 100644--- a/crates/dbx-sql-dialect/src/sql_dialect/identifiers.rs+++ b/crates/dbx-sql-dialect/src/sql_dialect/identifiers.rs@@ -170,6 +170,7 @@ pub fn quote_table_identifier(database_type: Option<DatabaseType>, name: &str) -}Some(DatabaseType::Informix) if is_simple_informix_identifier(name) => name.to_string(),Some(DatabaseType::Neo4j) => format!("`{}`", name.replace('`', "``")),+ Some(DatabaseType::Nebula) => format!("`{}`", name.replace('\\', "\\\\").replace('`', "\\`")),Some(DatabaseType::SqlServer) => format!("[{}]", name.replace(']', "]]")),_ => format!("\"{}\"", name.replace('"', "\"\"")),}diff --git a/crates/dbx-sql-dialect/src/sql_dialect/table_select.rs b/crates/dbx-sql-dialect/src/sql_dialect/table_select.rsindex c78dd66157..cd2ed03013 100644--- a/crates/dbx-sql-dialect/src/sql_dialect/table_select.rs+++ b/crates/dbx-sql-dialect/src/sql_dialect/table_select.rs@@ -200,6 +200,9 @@ pub fn build_table_data_select_sql_with_database(if database_type == Some(DatabaseType::Neo4j) {return build_neo4j_table_select_sql(&options, limit);}+ if database_type == Some(DatabaseType::Nebula) {+ return build_nebula_table_select_sql(&options, limit);+ }if database_type == Some(DatabaseType::Salesforce) {return build_salesforce_table_select_sql(&options, limit);}@@ -939,6 +942,47 @@ pub(super) fn build_neo4j_table_select_sql(options: &TableDataSelectSqlOptions,format!("MATCH (n:{label}){where_clause} RETURN {returns}{order}{skip} LIMIT {limit};")}+fn build_nebula_table_select_sql(options: &TableDataSelectSqlOptions, limit: usize) -> String {+ let quote = |name: &str| quote_table_identifier(Some(DatabaseType::Nebula), name);+ let kind = quote(&options.table_name);+ let is_edge = options.table_type.as_deref().is_some_and(|kind| kind.eq_ignore_ascii_case("VIEW"));+ let (pattern, identity, projection) = if is_edge {+ let projection = if options.columns.is_empty() {+ "e AS `edge`".to_string()+ } else {+ options+ .columns+ .iter()+ .map(|column| format!("e.{} AS {}", quote(column), quote(column)))+ .collect::<Vec<_>>()+ .join(", ")+ };+ (format!("MATCH ()-[e:{kind}]->()"), "src(e) AS `_src`, dst(e) AS `_dst`, rank(e) AS `_rank`", projection)+ } else {+ let projection = if options.columns.is_empty() {+ "v AS `vertex`".to_string()+ } else {+ options+ .columns+ .iter()+ .map(|column| format!("v.{kind}.{} AS {}", quote(column), quote(column)))+ .collect::<Vec<_>>()+ .join(", ")+ };+ (format!("MATCH (v:{kind})"), "id(v) AS `_vid`", projection)+ };+ let predicate = normalize_where_input(options.where_input.as_deref());+ let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE {predicate}") };+ let order = options+ .order_by+ .as_deref()+ .filter(|order| !order.trim().is_empty())+ .map(|order| format!(" ORDER BY {order}"))+ .unwrap_or_default();+ let skip = options.offset.filter(|offset| *offset > 0).map(|offset| format!(" SKIP {offset}")).unwrap_or_default();+ format!("{pattern}{where_clause} RETURN {identity}, {projection}{order}{skip} LIMIT {limit};")+}+/// Salesforce's `FIELDS(ALL)` selector is only legal with a LIMIT of 200 or less.const SALESFORCE_FIELDS_ALL_MAX_LIMIT: usize = 200;diff --git a/crates/dbx-sql-dialect/src/sql_dialect/tests.rs b/crates/dbx-sql-dialect/src/sql_dialect/tests.rsindex f5ee5736db..17c848dcb7 100644--- a/crates/dbx-sql-dialect/src/sql_dialect/tests.rs+++ b/crates/dbx-sql-dialect/src/sql_dialect/tests.rs@@ -17,6 +17,7 @@ fn transfer_identifier_policy_preserves_legacy_output() {#[test]fn quotes_identifiers_by_database_type() {+ assert_eq!(quote_table_identifier(Some(DatabaseType::Nebula), "tag`name"), "`tag\\`name`");assert_eq!(quote_table_identifier(Some(DatabaseType::Mysql), "user`name"), "`user``name`");assert_eq!(quote_table_identifier(Some(DatabaseType::ClickHouse), "user`name"), "`user``name`");assert_eq!(quote_table_identifier(Some(DatabaseType::Doris), "user`name"), "`user``name`");@@ -50,6 +51,29 @@ fn quotes_identifiers_by_database_type() {assert!(is_schema_aware(DatabaseType::Argo));}+#[test]+fn builds_nebula_tag_and_edge_queries() {+ let tag = build_table_data_select_sql(TableDataSelectSqlOptions {+ database_type: Some(DatabaseType::Nebula),+ table_name: "player".into(),+ table_type: Some("TABLE".into()),+ columns: vec!["name".into()],+ limit: Some(20),+ ..Default::default()+ });+ assert_eq!(tag, "MATCH (v:`player`) RETURN id(v) AS `_vid`, v.`player`.`name` AS `name` LIMIT 20;");++ let edge = build_table_data_select_sql(TableDataSelectSqlOptions {+ database_type: Some(DatabaseType::Nebula),+ table_name: "serve".into(),+ table_type: Some("VIEW".into()),+ columns: vec!["start_year".into()],+ limit: Some(10),+ ..Default::default()+ });+ assert_eq!(edge, "MATCH ()-[e:`serve`]->() RETURN src(e) AS `_src`, dst(e) AS `_dst`, rank(e) AS `_rank`, e.`start_year` AS `start_year` LIMIT 10;");+}+/// Spanner databases are created in one of two immutable dialects. The connected/// agent reports the correct identifier quote; when it is missing the static mapping/// must fall back to GoogleSQL (backticks), because GoogleSQL treats double quotes asdiff --git a/crates/dbx-types/src/models/connection.rs b/crates/dbx-types/src/models/connection.rsindex dd01f28d30..4416c5f5ee 100644--- a/crates/dbx-types/src/models/connection.rs+++ b/crates/dbx-types/src/models/connection.rs@@ -1185,6 +1185,7 @@ impl ConnectionConfig {DatabaseType::Db2 => format!("db2://{host}:{port}{db_part}"),DatabaseType::Informix => format!("informix://{host}:{port}{db_part}"),DatabaseType::Neo4j => format!("neo4j://{host}:{port}{db_part}"),+ DatabaseType::Nebula => format!("nebula://{host}:{port}{db_part}"),DatabaseType::Cassandra => format!("cassandra://{host}:{port}{db_part}"),DatabaseType::Bigquery => format!("bigquery://{host}/{db_part}"),DatabaseType::Spanner => self.spanner_display_url(&host, port),@@ -1442,6 +1443,9 @@ impl ConnectionConfig {DatabaseType::Neo4j => {format!("neo4j://{}:{}@{host}:{port}{db_part}", username, password)}+ DatabaseType::Nebula => {+ format!("nebula://{}:{}@{host}:{port}{db_part}", username, password)+ }DatabaseType::Cassandra => {format!("cassandra://{}:{}@{host}:{port}{db_part}", username, password)}diff --git a/docs/screenshots/nebula-graph-connection.png b/docs/screenshots/nebula-graph-connection.pngnew file mode 100644index 0000000000..56dd6aefeeBinary files /dev/null and b/docs/screenshots/nebula-graph-connection.png differdiff --git a/plugins/connection-types/nebula.yaml b/plugins/connection-types/nebula.yamlnew file mode 100644index 0000000000..f9638f156c--- /dev/null+++ b/plugins/connection-types/nebula.yaml@@ -0,0 +1,37 @@+schemaVersion: 1+order: 565+dbType: nebula+rustVariant: Nebula+label: NebulaGraph+runtimeMode: agent+mcpMode: bridge+agentKey: nebula+driverProfiles:+ - profile: nebula-v3+ agentKey: nebula+ label: NebulaGraph 3.x+ storeVisible: false+driverStoreVisible: true+driverStoreOrder: 53+singleConnectionPool: false+metadataConnectionScoped: false+skipTcpProbe: true+defaultPort: 9669+supportLevel: browse+capabilities:+ queryExecution: true+ metadataBrowse: true+ objectBrowser: true+ objectSource: true+ schemaSearch: false+ diagram: false+ tableDataEdit: false+ tableStructureEdit: false+ tableImport: false+ dataTransfer: false+ sqlFileExecution: false+ databaseCreate: false+ fieldLineage: false+ sqlExplain: false+ userAdmin: false+ driverManagement: truediff --git a/plugins/connection-types/profiles/catalog.yaml b/plugins/connection-types/profiles/catalog.yamlindex 67dd66cc18..0711e93002 100644--- a/plugins/connection-types/profiles/catalog.yaml+++ b/plugins/connection-types/profiles/catalog.yaml@@ -545,6 +545,13 @@ profiles:port: 7687user: neo4jcategory: graph_ai+ - id: nebula+ dbType: nebula+ label: NebulaGraph+ icon: nebula+ port: 9669+ user: root+ category: graph_ai- id: cassandradbType: cassandralabel: Cassandra