Neo4j自增ID机制及按插入顺序返回节点的方案咨询

First off, let's clear up the confusion around Neo4j's internal node IDs: they are not strictly sequential or guaranteed to reflect insertion order. Even though they might seem like auto-incrementing values at first glance, here's what's actually happening:

• Neo4j reuses internal IDs when nodes (or relationships) are deleted. Those "freed up" IDs get assigned to new nodes later on. In your case, the IDs 18208 and 18209 were likely from nodes you deleted before running your CREATE statements—so Paul and Andrew got those reused IDs, while the rest got the next available sequential IDs.
• The internal ID is tied to how Neo4j stores data on disk (it's a pointer to the node's position in the store file), not a reliable marker of insertion time or order. The official Neo4j docs explicitly warn against using internal IDs for business logic or ordering purposes, since their behavior can change between versions or due to database operations like deletions, backups, or restores.

You mentioned you considered timestamps but didn't think it was the best option—let's break down the practical, reliable approaches:

1. Explicit Sequential Order Attribute #

This is the most straightforward and foolproof method. When creating your nodes, add an explicit numeric attribute (like insertion_order) that increments with each node:

CREATE (p1:Person {name:"Marc", insertion_order:1})
CREATE (p2:Person {name:"John", insertion_order:2})
CREATE (p3:Person {name:"Paul", insertion_order:3})
CREATE (p4:Person {name:"Steve", insertion_order:4})
CREATE (p5:Person {name:"Andrew", insertion_order:5})
CREATE (p6:Person {name:"Alice", insertion_order:6})
CREATE (p7:Person {name:"Bob", insertion_order:7})

Then query with:

MATCH (p:Person)
RETURN p
ORDER BY p.insertion_order

If you're inserting nodes in bulk (like from a list), you can use UNWIND with an index to automate the sequence:

UNWIND ["Marc", "John", "Paul", "Steve", "Andrew", "Alice", "Bob"] AS name 
WITH name, apoc.coll.indexOf(["Marc", "John", "Paul", "Steve", "Andrew", "Alice", "Bob"], name) + 1 AS order
CREATE (p:Person {name: name, insertion_order: order})

(Note: APOC is a built-in library in most Neo4j distributions—just ensure it's enabled in your config.)

2. Timestamp with Nanosecond Precision #

If you don't want to manage a manual sequence, use Neo4j's datetime().nanoseconds to get a high-precision timestamp when creating nodes. Unlike timestamp() (which is millisecond precision and can have collisions in high-concurrency inserts), nanoseconds are unique for single-threaded inserts:

CREATE (p1:Person {name:"Marc", created_at: datetime().nanoseconds})
CREATE (p2:Person {name:"John", created_at: datetime().nanoseconds})
...

Query with:

MATCH (p:Person)
RETURN p
ORDER BY p.created_at

This works well if you don't need to control the sequence manually, and avoids ID reuse issues entirely.

Why These Are Better Than Relying on id() #

Both methods give you full control over the ordering, and aren't affected by node deletions, database maintenance, or Neo4j's internal storage mechanics. The internal id() is designed for Neo4j's own use—never for application-level ordering or identification.

内容的提问来源于stack exchange，提问作者Davide