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
fix(neo4j): correct label grids typed saves and menus
Hand Sonic6a2a15796e9d
diff --git a/agents/drivers/neo4j-go/main_test.go b/agents/drivers/neo4j-go/main_test.goindex c612cb8ca9..2c712445a5 100644--- a/agents/drivers/neo4j-go/main_test.go+++ b/agents/drivers/neo4j-go/main_test.go@@ -267,6 +267,26 @@ func TestDecodeQueryOptions(t *testing.T) {}}+func TestPropertyColumnsUseCypherTypesAndMergeLabelCombinations(t *testing.T) {+ record := func(name string, types []any, mandatory bool) *neo4j.Record {+ return &neo4j.Record{Keys: []string{"propertyName", "propertyTypes", "mandatory"}, Values: []any{name, types, mandatory}}+ }+ got := propertyColumns([]*neo4j.Record{+ record("score", []any{"Long"}, true),+ record("ratio", []any{"Double"}, true),+ record("score", []any{"String", "Long"}, false),+ record("values", []any{"LongArray", "DoubleArray"}, false),+ })+ want := []columnInfo{+ {Name: "ratio", DataType: "Float", IsNullable: false},+ {Name: "score", DataType: "Integer | String", IsNullable: true},+ {Name: "values", DataType: "FloatArray | IntegerArray", IsNullable: true},+ }+ if !reflect.DeepEqual(got, want) {+ t.Fatalf("propertyColumns() = %#v, want %#v", got, want)+ }+}+func TestBoundedQueryUsesFetchAll(t *testing.T) {options := queryOptions{SQL: "MATCH (n) RETURN n LIMIT 10000", MaxRows: 10000}if got := effectiveFetchSize(options); got != neo4j.FetchAll {diff --git a/agents/drivers/neo4j-go/metadata.go b/agents/drivers/neo4j-go/metadata.goindex df87452e1f..e064c65c02 100644--- a/agents/drivers/neo4j-go/metadata.go+++ b/agents/drivers/neo4j-go/metadata.go@@ -185,30 +185,57 @@ func (s *server) getColumns(label string) ([]columnInfo, error) {return nil, err}}- result := make([]columnInfo, 0, len(records))- seen := map[string]struct{}{}+ return propertyColumns(records), nil+}++func propertyColumns(records []*neo4j.Record) []columnInfo {+ columns := map[string]*columnInfo{}+ typesByName := map[string]map[string]struct{}{}for _, record := range records {name := recordString(record, "propertyName")if name == "" {continue}- if _, exists := seen[name]; exists {- continue+ column := columns[name]+ if column == nil {+ column = &columnInfo{Name: name}+ columns[name] = column+ typesByName[name] = map[string]struct{}{}}- seen[name] = struct{}{}- types := recordStringSlice(record, "propertyTypes")- dataType := "Unknown"+ column.IsNullable = column.IsNullable || !recordBool(record, "mandatory")+ for _, kind := range recordStringSlice(record, "propertyTypes") {+ typesByName[name][propertyTypeName(kind)] = struct{}{}+ }+ }+ result := make([]columnInfo, 0, len(columns))+ for name, column := range columns {+ types := make([]string, 0, len(typesByName[name]))+ for kind := range typesByName[name] {+ types = append(types, kind)+ }+ sort.Strings(types)+ column.DataType = "Unknown"if len(types) > 0 {- dataType = strings.Join(types, " | ")+ column.DataType = strings.Join(types, " | ")}- result = append(result, columnInfo{- Name: name,- DataType: dataType,- IsNullable: !recordBool(record, "mandatory"),- })+ result = append(result, *column)}sort.Slice(result, func(left, right int) bool { return result[left].Name < result[right].Name })- return result, nil+ return result+}++func propertyTypeName(kind string) string {+ if element, ok := strings.CutSuffix(kind, "Array"); ok {+ return propertyTypeName(element) + "Array"+ }+ switch kind {+ case "Long":+ return "Integer"+ case "Double":+ return "Float"+ default:+ return kind+ }}func (s *server) listIndexes(label string) ([]indexInfo, error) {diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vueindex 38aae432b9..994c227ac1 100644--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue@@ -2792,7 +2792,7 @@ function requestDropTableChildObject() {}function canDropTreeNode(node: TreeNode): boolean {- if (databaseTypeForNode(node) === "nebula") return false;+ if (["neo4j", "nebula"].includes(databaseTypeForNode(node) || "")) 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") {@@ -3135,7 +3135,7 @@ function requestDropSelectedNodes(): boolean {}function requestDropSelectedNode(): boolean {- if (currentDatabaseType() === "nebula") return false;+ if (["neo4j", "nebula"].includes(currentDatabaseType() || "")) return false;if (activeNode.value.type === "table") {dropTable();return true;@@ -4760,7 +4760,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", "nebula"].includes(dbType || "");+ return !["redis", "mongodb", "dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "consul", "mq", "nacos", "plugin", "salesforce", "neo4j", "nebula"].includes(dbType || "");});const canOpenScheduledBackups = computed(() => {@@ -5867,15 +5867,17 @@ function buildDatabaseSidebarMenu(context: SidebarMenuFactoryContext): boolean {});return true;}- if (currentDatabaseType() === "nebula" && node.type === "database") {+ if (["neo4j", "nebula"].includes(currentDatabaseType() || "") && 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 });+ if (supportsAiAssistantContext(currentDatabaseType())) items.push(addToAiMenuItem(node));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 });+ if (canOpenSqlFileExecution.value) items.push({ label: t("sqlFile.title"), action: openSqlFileExecution, icon: FileCode });items.push({ label: "", separator: true });items.push({ label: t("contextMenu.refreshChildren"), action: refresh, icon: RefreshCw, shortcut: shortcutRefresh });return true;@@ -6286,13 +6288,15 @@ function buildObjectSidebarMenu(context: SidebarMenuFactoryContext): boolean {appendPluginTableMenuItems(items, node);return true;}- if (currentDatabaseType() === "nebula") {+ if (["neo4j", "nebula"].includes(currentDatabaseType() || "")) {items.push(copyNameMenuItem());items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });+ if (supportsAiAssistantContext(currentDatabaseType())) items.push(addToAiMenuItem(node));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 });+ if (currentDatabaseType() === "nebula") items.push({ label: t("contextMenu.viewDdl"), action: openDdl, icon: FileCode });+ if (currentDatabaseType() === "neo4j") items.push(exportDataSubmenu(false));const sqlHistoryMenu = savedSqlHistorySubmenu();if (sqlHistoryMenu) items.push(sqlHistoryMenu);items.push({ label: "", separator: true });@@ -6652,7 +6656,8 @@ 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 && currentDatabaseType() !== "nebula") || !!mysqlObjectTemplate || hasMongoCreateIndexAction || hasMongoDropAllIndexesAction;+ const canCreateGroupView = node.type === "group-views" && !!node.connectionId && !!node.database && !["neo4j", "nebula"].includes(currentDatabaseType() || "");+ const hasGroupAction = (node.type === "group-tables" && canCreateTable.value) || canCreateGroupView || !!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 });@@ -6663,7 +6668,7 @@ function buildObjectGroupSidebarMenu(context: SidebarMenuFactoryContext): booleaitems.push({ label: t("contextMenu.pasteTable"), action: openPasteTableDialog, icon: Clipboard });}}- if (node.type === "group-views" && node.connectionId && node.database && currentDatabaseType() !== "nebula") {+ if (canCreateGroupView) {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.neo4jContextMenu.spec.ts b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.neo4jContextMenu.spec.tsnew file mode 100644index 0000000000..6557488d0a--- /dev/null+++ b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.neo4jContextMenu.spec.ts@@ -0,0 +1,77 @@+// @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 { DatabaseType, TreeNode } from "@/types/database";+import { supportsTableTruncate } from "@/lib/database/databaseFeatureSupport";++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 node = (type: TreeNode["type"], label: string): TreeNode => ({ id: `sample:${type}:${label}`, type, label, connectionId: "sample", database: "sample", 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(dbType: DatabaseType = "neo4j") {+ const pinia = createPinia();+ setActivePinia(pinia);+ useConnectionStore().connections = [{ id: "sample", name: "Sample", db_type: dbType, driver_profile: dbType, host: "localhost", port: 7687, username: "sample", password: "" }];+ const host = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);+ const root = defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: node("connection", "Sample"), 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("Neo4j sidebar capabilities", () => {+ afterEach(() => {+ for (const app of mountedApps.splice(0)) app.unmount();+ document.body.innerHTML = "";+ });++ it("keeps database browsing and queries without relational comparisons or transfers", async () => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node("database", "sample")));+ expect(items).toEqual(expect.arrayContaining([tr("contextMenu.newQuery"), tr("contextMenu.openObjectBrowser"), tr("contextMenu.refreshChildren"), tr("sqlFile.title")]));+ for (const key of ["transfer.dataTransfer", "diff.title", "dataCompare.title", "contextMenu.exportDatabase", "dataDictionary.title"]) expect(items).not.toContain(tr(key));+ });++ it.each(["table", "view"] as const)("keeps %s data browsing without SQL structure mutations", async (type) => {+ const host = await mountHost();+ const items = labels(host.buildContextMenu(node(type, "Person")));+ expect(items).toEqual(expect.arrayContaining([tr("contextMenu.viewData"), tr("contextMenu.newQuery"), tr("contextMenu.exportData")]));+ for (const key of ["contextMenu.viewDdl", "contextMenu.generateSql", "contextMenu.duplicateStructure", "contextMenu.dropTable", "contextMenu.dropView", "contextMenu.truncateTable", "contextMenu.emptyTable", "contextMenu.exportDatabase", "dataCompare.title"]) expect(items).not.toContain(tr(key));+ });++ it("does not offer SQL view creation or relational database backups", async () => {+ const host = await mountHost();+ expect(labels(host.buildContextMenu(node("group-views", "Views")))).not.toContain(tr("contextMenu.createView"));+ const connectionItems = labels(host.buildContextMenu(node("connection", "Sample")));+ expect(connectionItems).toContain(tr("contextMenu.newQuery"));+ expect(connectionItems).not.toContain(tr("contextMenu.exportAllDatabases"));+ expect(supportsTableTruncate("neo4j")).toBe(false);+ });++ it("preserves MySQL relational menus", async () => {+ const host = await mountHost("mysql");+ expect(labels(host.buildContextMenu(node("database", "sample")))).toContain(tr("transfer.dataTransfer"));+ expect(labels(host.buildContextMenu(node("table", "Person")))).toContain(tr("contextMenu.generateSql"));+ expect(supportsTableTruncate("mysql")).toBe(true);+ });+});diff --git a/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts b/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.tsindex 3f397b2021..4600ea17cd 100644--- a/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts+++ b/apps/desktop/src/composables/__tests__/useSidebarDataOpenRuntime.spec.ts@@ -425,8 +425,8 @@ describe("useSidebarDataOpenRuntime", () => {});});- it("waits for NebulaGraph properties before building the first table query", async () => {- mocks.databaseType = "nebula";+ it.each(["nebula", "neo4j"])("waits for %s properties before building the first table query", async (databaseType) => {+ mocks.databaseType = databaseType;let releaseMetadata: () => void = () => {};const gate = new Promise<void>((resolve) => {releaseMetadata = resolve;@@ -455,7 +455,7 @@ describe("useSidebarDataOpenRuntime", () => {releaseMetadata();await opening;- expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ databaseType: "nebula", columns: ["name"] }));+ expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ databaseType, columns: ["name"] }));expect(mocks.callOrder).toEqual(["query"]);});diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.tsindex e2e98a0044..1f45009929 100644--- a/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts@@ -64,6 +64,13 @@ describe("dataGridCellDisplayText", () => {});describe("coerceDataGridCellValue", () => {+ it.each(["Integer", "Long", "int"])("keeps Neo4j %s edits as exact text for the Cypher builder", (data_type) => {+ for (const value of ["1001", "9007199254740999", "9223372036854775807", "-9223372036854775808"]) {+ expect(coerceDataGridCellValue({ value, oldValue: "1", databaseType: "neo4j", columnInfo: { data_type } })).toBe(value);+ expect(coerceDataGridCellValue({ value: `${value}\n`, oldValue: "1", databaseType: "neo4j", columnInfo: { data_type } })).toBe(value);+ }+ });+it.each(["null", "NULL", "Null", "nUlL"])("preserves literal %s input as text", (value) => {expect(coerceDataGridCellValue({diff --git a/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.tsindex c68b3f89cf..1239c7f587 100644--- a/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts+++ b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts@@ -323,6 +323,7 @@ describe("quoteTableIdentifier", () => {expect(requiresEagerTableMetadataForDataOpen("mysql")).toBe(true);expect(requiresEagerTableMetadataForDataOpen("postgres")).toBe(true);expect(requiresEagerTableMetadataForDataOpen("nebula")).toBe(true);+ expect(requiresEagerTableMetadataForDataOpen("neo4j")).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/dataGrid/dataGridCellCoercion.ts b/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.tsindex da75ff582c..e1133923c1 100644--- a/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts+++ b/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts@@ -37,6 +37,9 @@ export function coerceDataGridCellValue(options: CoerceDataGridCellValueOptions)const useSampledValueType = normalizeDataType(options.columnInfo?.data_type) === "";const numericInput = isNumericColumnType(options.columnInfo?.data_type) || (useSampledValueType && typeof oldValue === "number");const numericText = normalizeGroupedNumberText(value, options.columnInfo, oldValue, options.numberFormat ?? runtimeNumberFormat());+ // Neo4j INTEGER is always signed 64-bit. Keep its input as text until the+ // Cypher builder validates it, including values outside JavaScript's range.+ if (options.databaseType === "neo4j" && ["integer", "long", "int"].includes(normalizeDataType(options.columnInfo?.data_type))) return numericText.trim();if (isBooleanInputColumn(options) || (useSampledValueType && typeof oldValue === "boolean")) {// MySQL exposes TINYINT(1) as an integer in the grid. Keep its numeric// 0/1 edits numeric while still accepting explicit TRUE/FALSE aliases.diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.tsindex 3891a43042..eb3a273c7a 100644--- a/apps/desktop/src/lib/database/databaseFeatureSupport.ts+++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts@@ -268,6 +268,7 @@ export function supportsTableTruncate(dbType?: DatabaseType): boolean {dbType !== "victoriametrics" &&dbType !== "manticoresearch" &&dbType !== "salesforce" &&+ dbType !== "neo4j" &&dbType !== "nebula");}diff --git a/apps/desktop/src/lib/table/tableSelectSql.ts b/apps/desktop/src/lib/table/tableSelectSql.tsindex 26fdaabf94..2ef8c9169a 100644--- a/apps/desktop/src/lib/table/tableSelectSql.ts+++ b/apps/desktop/src/lib/table/tableSelectSql.ts@@ -447,11 +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+ * * Neo4j/NebulaGraph: without node/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" || databaseType === "nebula";+ return databaseType === "mysql" || databaseType === "postgres" || databaseType === "salesforce" || databaseType === "neo4j" || databaseType === "nebula";}export async function buildTableSelectSql(options: BuildTableSelectSqlOptions): Promise<string> {diff --git a/crates/dbx-sql-data/src/data_grid_neo4j_sql.rs b/crates/dbx-sql-data/src/data_grid_neo4j_sql.rsindex 9136cece46..78e3dadd38 100644--- a/crates/dbx-sql-data/src/data_grid_neo4j_sql.rs+++ b/crates/dbx-sql-data/src/data_grid_neo4j_sql.rs@@ -4,7 +4,9 @@ use super::*;use crate::models::connection::DatabaseType;use crate::sql_dialect::{neo4j_element_id_function, NEO4J_LEGACY_ELEMENT_ID_FUNCTION};-pub(super) fn build_neo4j_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {+pub(super) fn build_neo4j_data_grid_save_statements(+ options: &DataGridSaveStatementOptions,+) -> Result<Vec<String>, String> {let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_meta.table_name);let element_id_function = neo4j_element_id_function(options.server_version.as_deref());let mut statements = Vec::new();@@ -20,13 +22,12 @@ pub(super) fn build_neo4j_data_grid_save_statements(options: &DataGridSaveStatemif is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {return None;}- Some(format!(- "n.{} = {}",- quote_ident(Some(DatabaseType::Neo4j), column),- format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)- ))+ Some(+ property_literal(options, column, value)+ .map(|literal| format!("n.{} = {}", quote_ident(Some(DatabaseType::Neo4j), column), literal)),+ )})- .collect::<Vec<_>>()+ .collect::<Result<Vec<_>, _>>()?.join(", ");if sets.is_empty() {continue;@@ -58,13 +59,12 @@ pub(super) fn build_neo4j_data_grid_save_statements(options: &DataGridSaveStatemif value.is_null() {return None;}- Some(format!(- "{}: {}",- quote_ident(Some(DatabaseType::Neo4j), column),- format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)- ))+ Some(+ property_literal(options, column, value)+ .map(|literal| format!("{}: {}", quote_ident(Some(DatabaseType::Neo4j), column), literal)),+ )})- .collect::<Vec<_>>()+ .collect::<Result<Vec<_>, _>>()?.join(", ");statements.push(if props.is_empty() {format!("CREATE (n:{label});")@@ -73,52 +73,21 @@ pub(super) fn build_neo4j_data_grid_save_statements(options: &DataGridSaveStatem});}- statements+ Ok(statements)}-pub(super) fn build_neo4j_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {+pub(super) fn build_neo4j_data_grid_rollback_statements(+ options: &DataGridSaveStatementOptions,+) -> Result<Vec<String>, String> {+ // Matching inserted properties can delete other nodes, and recreating a+ // detached node cannot restore its identity or relationships.+ if !options.new_rows.is_empty() || !options.deleted_rows.is_empty() {+ return Ok(Vec::new());+ }let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_meta.table_name);let element_id_function = neo4j_element_id_function(options.server_version.as_deref());let mut statements = Vec::new();- for row in &options.new_rows {- let where_clause = neo4j_row_property_where(&options.columns, row);- statements.push(if where_clause.is_empty() {- format!("MATCH (n:{label}) DETACH DELETE n;")- } else {- format!("MATCH (n:{label}) WHERE {where_clause} DETACH DELETE n;")- });- }-- for row_index in &options.deleted_rows {- let Some(row) = options.rows.get(*row_index) else {- continue;- };- let props = options- .columns- .iter()- .enumerate()- .filter(|(_, column)| !is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)))- .filter_map(|(index, column)| {- let value = row.get(index).unwrap_or(&Value::Null);- if value.is_null() {- return None;- }- Some(format!(- "{}: {}",- quote_ident(Some(DatabaseType::Neo4j), column),- format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)- ))- })- .collect::<Vec<_>>()- .join(", ");- statements.push(if props.is_empty() {- format!("CREATE (n:{label});")- } else {- format!("CREATE (n:{label} {{{props}}});")- });- }-for (row_index, changes) in &options.dirty_rows {let Some(row) = options.rows.get(*row_index) else {continue;@@ -130,17 +99,12 @@ pub(super) fn build_neo4j_data_grid_rollback_statements(options: &DataGridSaveStif is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {return None;}- Some(format!(- "n.{} = {}",- quote_ident(Some(DatabaseType::Neo4j), column),- format_grid_sql_literal(- row.get(*column_index).unwrap_or(&Value::Null),- Some(DatabaseType::Neo4j),- None- )- ))+ Some(+ property_literal(options, column, row.get(*column_index).unwrap_or(&Value::Null))+ .map(|literal| format!("n.{} = {}", quote_ident(Some(DatabaseType::Neo4j), column), literal)),+ )})- .collect::<Vec<_>>()+ .collect::<Result<Vec<_>, _>>()?.join(", ");if sets.is_empty() {continue;@@ -151,7 +115,7 @@ pub(super) fn build_neo4j_data_grid_rollback_statements(options: &DataGridSaveSt));}- statements+ Ok(statements)}fn neo4j_element_id_predicate(columns: &[String], row: &[Value], element_id_function: &str) -> String {@@ -182,22 +146,76 @@ fn neo4j_legacy_element_id_literal(value: &Value) -> Option<String> {}}-fn neo4j_row_property_where(columns: &[String], row: &[Value]) -> String {- columns+fn property_literal(options: &DataGridSaveStatementOptions, column: &str, value: &Value) -> Result<String, String> {+ // Cypher property names are case-sensitive, unlike relational metadata lookups.+ let data_type = options+ .table_meta+ .columns+ .as_deref()+ .unwrap_or(&[]).iter()- .enumerate()- .filter_map(|(index, column)| {- if is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {- return None;+ .find(|info| info.name == column)+ .map(|info| info.data_type.as_str())+ .unwrap_or("");+ typed_property_literal(value, data_type)+ .map_err(|error| format!("Cannot save Neo4j property `{column}` ({data_type}): {error}"))+}++fn typed_property_literal(value: &Value, data_type: &str) -> Result<String, &'static str> {+ if value.is_null() {+ return Ok("NULL".to_string());+ }+ let kind = data_type.trim().to_ascii_lowercase();+ if let Some(element_type) = kind.strip_suffix("array").or_else(|| kind.strip_suffix("[]")) {+ let parsed;+ let items = if let Some(items) = value.as_array() {+ items+ } else {+ parsed = serde_json::from_str::<Value>(value.as_str().ok_or("expected a JSON array")?)+ .map_err(|_| "expected a JSON array")?;+ parsed.as_array().ok_or("expected a JSON array")?+ };+ let values = items+ .iter()+ .map(|item| {+ if item.is_null() {+ return Err("property arrays cannot contain null");+ }+ typed_property_literal(item, element_type)+ })+ .collect::<Result<Vec<_>, _>>()?;+ return Ok(format!("[{}]", values.join(", ")));+ }+ let text = value.as_str().map(str::to_string).unwrap_or_else(|| value.to_string());+ let quoted = || format_grid_sql_literal(&Value::String(text.clone()), Some(DatabaseType::Neo4j), None);+ match kind.as_str() {+ "long" | "integer" | "int" => {+ let number = text.trim().parse::<i64>().map_err(|_| "expected a signed 64-bit integer")?;+ // Keep exact integers out of JavaScript floating-point conversions and+ // support the full signed range, including the minimum integer literal.+ Ok(format!("toInteger('{number}')"))+ }+ "double" | "float" => {+ let number = text.trim().parse::<f64>().map_err(|_| "expected a finite float")?;+ if !number.is_finite() {+ return Err("expected a finite float");}- let value = row.get(index).unwrap_or(&Value::Null);- let ident = format!("n.{}", quote_ident(Some(DatabaseType::Neo4j), column));- if value.is_null() {- Some(format!("{ident} IS NULL"))- } else {- Some(format!("{ident} = {}", format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)))+ Ok(format!("toFloat({})", quoted()))+ }+ "boolean" | "bool" => match text.trim().to_ascii_lowercase().as_str() {+ "true" => Ok("true".to_string()),+ "false" => Ok("false".to_string()),+ _ => Err("expected true or false"),+ },+ "string" => {+ if !value.is_string() {+ return Err("expected a string");}- })- .collect::<Vec<_>>()- .join(" AND ")+ Ok(quoted())+ }+ "date" => Ok(format!("date({})", quoted())),+ "duration" => Ok(format!("duration({})", quoted())),+ // A mixed or unsupported property type must not silently become a string.+ _ => Err("this property type requires an explicit Cypher query"),+ }}diff --git a/crates/dbx-sql-data/src/data_grid_sql.rs b/crates/dbx-sql-data/src/data_grid_sql.rsindex 5a7faba63d..619af263a8 100644--- a/crates/dbx-sql-data/src/data_grid_sql.rs+++ b/crates/dbx-sql-data/src/data_grid_sql.rs@@ -403,6 +403,22 @@ pub fn prepare_data_grid_save_for_driver_profile(}let mut keyless_guards = Vec::new();+ if options.database_type == Some(DatabaseType::Neo4j) {+ let generated = build_neo4j_data_grid_save_statements(&options).and_then(|statements| {+ build_neo4j_data_grid_rollback_statements(&options).map(|rollback| (statements, rollback))+ });+ let (validation_error, statements, rollback_statements) = match generated {+ Ok((statements, rollback)) => (None, statements, rollback),+ Err(error) => (Some(error), Vec::new(), Vec::new()),+ };+ return DataGridSavePreparation {+ validation_error,+ statements,+ rollback_statements,+ execution_schema: None,+ keyless_guards,+ };+ }let statements = build_data_grid_save_statements(&options, driver_profile, &mut keyless_guards);DataGridSavePreparation {validation_error: None,@@ -1093,6 +1109,12 @@ fn is_sqlserver_legacy_profile(driver_profile: Option<&str>) -> bool {}pub fn build_data_grid_count_sql(options: DataGridCountSqlOptions) -> String {+ if options.database_type == Some(DatabaseType::Neo4j) {+ let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_name);+ let predicate = crate::sql_dialect::normalize_where_input(options.where_input.as_deref());+ let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };+ return format!("MATCH (n:{label}){where_clause} RETURN count(n) AS cnt");+ }// Keep the reference identical to the one the grid's SELECT uses: Caché/IRIS// reject quoted ordinary names when delimited identifiers are disabled, so// the count must not be the only statement that quotes them (#8929).@@ -1585,9 +1607,6 @@ fn build_data_grid_save_statements(driver_profile: Option<&str>,keyless_guards: &mut Vec<DataGridSaveGuard>,) -> Vec<String> {- if options.database_type == Some(DatabaseType::Neo4j) {- return build_neo4j_data_grid_save_statements(options);- }if options.database_type == Some(DatabaseType::Tdengine) {return build_tdengine_data_grid_save_statements(options);}@@ -1787,9 +1806,6 @@ fn build_data_grid_rollback_statements(options: &DataGridSaveStatementOptions,driver_profile: Option<&str>,) -> Vec<String> {- if options.database_type == Some(DatabaseType::Neo4j) {- return build_neo4j_data_grid_rollback_statements(options);- }if options.database_type == Some(DatabaseType::Tdengine) {return build_tdengine_data_grid_rollback_statements(options);}@@ -4274,6 +4290,113 @@ mod tests {assert_eq!(without_version.statements, on_neo4j_5.statements);}+ #[test]+ fn neo4j_property_writes_preserve_types_and_exact_integers() {+ for (kind, value, expected) in [+ ("Long", json!("9223372036854775807"), "toInteger('9223372036854775807')"),+ ("Integer", json!("-9223372036854775808"), "toInteger('-9223372036854775808')"),+ ("Double", json!(2), "toFloat('2')"),+ ("Boolean", json!("false"), "false"),+ ("Date", json!("2026-09-30"), "date('2026-09-30')"),+ ("Duration", json!("P1D"), "duration('P1D')"),+ ("StringArray", json!("[\"A\",\"B\"]"), "['A', 'B']"),+ ("LongArray", json!("[9007199254740997]"), "[toInteger('9007199254740997')]"),+ ("BooleanArray", json!([true, false]), "[true, false]"),+ ("String", json!("a'b\\c"), "'a\\'b\\\\c'"),+ ] {+ let prepared = prepare_data_grid_save(neo4j_property_save_options(kind, value));+ assert_eq!(prepared.validation_error, None, "{kind}");+ assert_eq!(+ prepared.statements,+ vec![format!("MATCH (n:`Person`) WHERE elementId(n) = 'sample-id' SET n.`value` = {expected};")]+ );+ assert_eq!(prepared.rollback_statements, prepared.statements);+ }+ }++ #[test]+ fn neo4j_property_writes_reject_invalid_and_ambiguous_types_before_execution() {+ for (kind, value) in [+ ("Long", json!("9223372036854775808")),+ ("Long", json!("1.5")),+ ("Long", json!("1); MATCH (n) DELETE n")),+ ("Double", json!("NaN")),+ ("Double", json!("Infinity")),+ ("Boolean", json!("not-a-boolean")),+ ("LongArray", json!("[null]")),+ ("StringArray", json!("[1]")),+ ("LongArray", json!("[1.5]")),+ ("StringArray", json!("invalid JSON")),+ ("Long | String", json!("12")),+ ("Unknown", json!("12")),+ ("Point", json!("{x:1,y:2}")),+ ] {+ let prepared = prepare_data_grid_save(neo4j_property_save_options(kind, value));+ assert!(prepared.validation_error.is_some(), "{kind}");+ assert!(prepared.statements.is_empty(), "{kind}");+ assert!(prepared.rollback_statements.is_empty(), "{kind}");+ }+ }++ #[test]+ fn neo4j_insert_and_delete_do_not_generate_unsafe_history_reversals() {+ let mut options = neo4j_property_save_options("Long", json!("9007199254740997"));+ options.dirty_rows.clear();+ options.new_rows = vec![vec![Value::Null, json!("9007199254740997")]];+ let prepared = prepare_data_grid_save(options.clone());+ assert_eq!(prepared.validation_error, None);+ assert_eq!(prepared.statements, vec!["CREATE (n:`Person` {`value`: toInteger('9007199254740997')});"]);+ assert!(prepared.rollback_statements.is_empty());+ options.new_rows.clear();+ options.deleted_rows = vec![0];+ let prepared = prepare_data_grid_save(options);+ assert_eq!(prepared.statements, vec!["MATCH (n:`Person`) WHERE elementId(n) = 'sample-id' DETACH DELETE n;"]);+ assert!(prepared.rollback_statements.is_empty());+ }++ fn neo4j_property_save_options(kind: &str, value: Value) -> DataGridSaveStatementOptions {+ DataGridSaveStatementOptions {+ database_type: Some(DatabaseType::Neo4j),+ identifier_quote: None,+ server_version: Some("Neo4j/5.26.0".to_string()),+ table_meta: DataGridTableMeta {+ catalog: None,+ database: None,+ schema: None,+ table_name: "Person".to_string(),+ primary_keys: vec![DBX_NEO4J_ELEMENT_ID_COLUMN.to_string()],+ columns: Some(vec![column("value", kind, true, None)]),+ },+ columns: vec![DBX_NEO4J_ELEMENT_ID_COLUMN.to_string(), "value".to_string()],+ source_columns: None,+ rows: vec![vec![json!("sample-id"), value.clone()]],+ dirty_rows: vec![(0, vec![(1, value)])],+ deleted_rows: vec![],+ new_rows: vec![],+ include_database_name: false,+ }+ }++ #[test]+ fn neo4j_counts_use_cypher_and_keep_the_grid_predicate() {+ for (where_input, where_clause) in [(None, ""), (Some("WHERE n.`age` > 10"), " WHERE (n.`age` > 10)")] {+ let options = DataGridCountSqlOptions {+ database_type: Some(DatabaseType::Neo4j),+ identifier_quote: None,+ catalog: None,+ database: Some("neo4j".to_string()),+ schema: Some("neo4j".to_string()),+ table_name: "P`erson".to_string(),+ where_input: where_input.map(str::to_string),+ count_hint: None,+ };+ assert_eq!(+ build_data_grid_count_sql(options),+ format!("MATCH (n:`P``erson`){where_clause} RETURN count(n) AS cnt")+ );+ }+ }+#[test]fn iris_cache_data_grid_save_uses_unquoted_ordinary_identifiers() {let result = prepare_data_grid_save(DataGridSaveStatementOptions {diff --git a/docs/screenshots/neo4j-basic-database-menu.png b/docs/screenshots/neo4j-basic-database-menu.pngnew file mode 100644index 0000000000..f8c3017c2fBinary files /dev/null and b/docs/screenshots/neo4j-basic-database-menu.png differdiff --git a/docs/screenshots/neo4j-basic-grid.png b/docs/screenshots/neo4j-basic-grid.pngnew file mode 100644index 0000000000..965182a1b9Binary files /dev/null and b/docs/screenshots/neo4j-basic-grid.png differ