# Neo4j Features and Practical Usage 🚪 Pick the wrong data-import method up front and every downstream step pays for it. Neo4j's "Import your data" hub helps you choose the right entry point based on scale and frequency. 🏷️ Title: Import method selection guide 🔗 URL: 📘 Overview Neo4j offers several ways to load data, each with different strengths in terms of scale, execution mode (online vs offline), and permission requirements. This page is not a step-by-step tutorial but a decision hub for choosing the right method before you start. ⚙️ How It Works The main options are: ・Data Importer: a browser-based GUI where you drag and drop CSVs and visually map columns to nodes and relationships. No Cypher required; ideal for testing and prototyping. ・`LOAD CSV`: a general-purpose Cypher-based loader. Runs online (database stays up) and is usable by non-admin users. Good up to hundreds of thousands or low millions of rows. ・`neo4j-admin database import`: an offline bulk loader that writes directly to the native store format, making it the fastest path for initial loading of very large datasets (billions of entities). ・Connectors / APOC: continuous sync via Apache Spark, Kafka, and CDC, plus support for diverse formats like JSON, XML, and XLS. 🛠️ Practical Usage Decide the entry point by scale and frequency: ・A few thousand master records, fast → Data Importer (GUI) ・Millions of rows on a schedule / incremental → `LOAD CSV` (made idempotent with `MERGE`) ・Billions of entities, one-shot initial build → `neo4j-admin database import` (offline) ・Always-on continuous sync → Kafka / CDC / Spark connectors Whatever the path, a shared best practice is to create a uniqueness constraint on the key column before importing. ```cypher CREATE CONSTRAINT person_id IF NOT EXISTS FOR (p:Person) REQUIRE IS UNIQUE; ``` 💡 Use Cases Early in a project, split the paths: Data Importer for the PoC, `neo4j-admin import` for the production initial build, and `LOAD CSV` for daily incrementals. This keeps validation light and fast while making the bulk load as fast as possible. ⚠️ Caveats ・`neo4j-admin import` targets an empty database and runs offline, so it cannot be used against a live database. ・`LOAD CSV` tends to hit memory issues as row counts approach hundreds of thousands to millions; split work with `CALL { } IN TRANSACTIONS`. ・Continuous sync (Kafka/CDC) is distinct from initial loading and should be designed alongside it. ・This page is just the entry point; confirm the details of each method in its dedicated docs. #Neo4j# #DataImport#

# Neo4j Features and Practical Usage 🔒 Create one uniqueness constraint before importing—and you get duplicate-proof MERGE plus fast lookups at the same time. The official docs list it as a prerequisite step for imports. 🏷️ Title: Uniqueness / Property existence / Node key constraints 🔗 URL: 📘 Overview Constraints enforce rules that nodes and relationships must satisfy, at the database layer. They guarantee key uniqueness and required properties, keeping entities consistent even when multiple pipelines write to the graph. Uniqueness constraints also create a backing range index, so lookups get faster too. ⚙️ How It Works ・Property uniqueness: guarantees a property value (or combination) is unique per label/type. Available in Community Edition, with a backing range index that optimizes MERGE and imports. ・Property existence: guarantees a given property is always present (Enterprise only). ・Property type: guarantees a property has the required type, preventing schema drift (Enterprise only). ・Key constraints (Node key / Relationship key): combine uniqueness and existence—equivalent to a composite primary key (Enterprise only). 🛠️ Practical Usage The uniqueness constraint to always create before importing: ```cypher CREATE CONSTRAINT person_id IF NOT EXISTS FOR (p:Person) REQUIRE IS UNIQUE; ``` A node key (composite key) and an existence constraint: ```cypher CREATE CONSTRAINT order_key IF NOT EXISTS FOR (o:Order) REQUIRE (o.tenantId, o.orderId) IS NODE KEY; CREATE CONSTRAINT user_email_exists IF NOT EXISTS FOR (u:User) REQUIRE IS NOT NULL; ``` Inspect and drop them: ```cypher SHOW CONSTRAINTS; DROP CONSTRAINT person_id IF EXISTS; ``` 💡 Use Cases ・Create a uniqueness constraint before a bulk import to get duplicate prevention and speedup in one move. ・Enforce key integrity for master-data nodes at the DB layer, preventing doubling even with multiple writing pipelines. ⚠️ Caveats ・Everything except uniqueness (existence, type, key) is Enterprise Edition only; Community supports uniqueness alone. ・Creating a constraint on data that already violates it fails. Clean the data first. ・Bulk imports are validated against active constraints and can fail on violations. ・For more sophisticated or centralized schema management, defining a schema via a graph type is recommended. #Neo4j# #Cypher#

# Neo4j Features and Practical Usage ⚡ "Even in a graph DB, index design is 80% of performance." Put the right index on your MATCH anchor property and lookups go from O(n) to O(log n). 🏷️ Title: Range / Text / Point / Composite index 🔗 URL: 📘 Overview An index is a copy of nodes, relationships, or properties that provides a fast access path to the primary data. Once created, the DBMS keeps it updated automatically. It speeds up the anchor (starting point) of a MATCH, and the Cypher planner selects it automatically based on the predicate. ⚙️ How It Works ・Range (default): solves the most predicates—equality, range comparisons, `IN`, and `STARTS WITH`. This is the first index to reach for. ・Text: `STRING`-only, optimized for `CONTAINS` and `ENDS WITH`—ideal for substring search screens. ・Point: for spatial `POINT` values, optimized for distance queries and bounding-box searches. ・Composite: indexes several properties together, solving multi-condition filters in one go. ・Token lookup: a foundational index that speeds up label / relationship-type lookups. ・Beyond these, full-text indexes and vector indexes (similarity search / GenAI) are also available. 🛠️ Practical Usage Creating range / composite / text / point indexes on anchor properties: ```cypher CREATE INDEX user_email IF NOT EXISTS FOR (u:User) ON ( CREATE INDEX order_composite IF NOT EXISTS FOR (o:Order) ON (o.customerId, o.status); CREATE TEXT INDEX product_name_text IF NOT EXISTS FOR (p:Product) ON ( CREATE POINT INDEX store_loc IF NOT EXISTS FOR (s:Store) ON (s.location); ``` Inspect and drop them: ```cypher SHOW INDEXES; DROP INDEX user_email IF EXISTS; ``` 💡 Use Cases ・Apps that anchor MATCH on ` `Order.orderId`, or `Product.sku`, making lookups O(log n). ・Search screens that pick range for `STARTS WITH`, text for `CONTAINS`/`ENDS WITH`, and point for geo queries. ⚠️ Caveats ・Which index applies depends on the predicate. `CONTAINS` is not served by a range index—it needs a text index. ・Indexes add write cost and storage. Confirm they are actually used with `PROFILE` before relying on them. ・Composite indexes apply from the leading property onward, so column order affects performance. #Neo4j# #Cypher#

# Neo4j Features and Practical Usage ♻️ "Create it if missing, update it if present." Idempotent writes that never produce duplicate nodes—no matter how many times you replay an event stream—come down to a single `MERGE`. 🏷️ Title: CREATE / MERGE / SET / DELETE 🔗 URL: 📘 Overview `MERGE` is an upsert clause: it matches and binds an existing pattern, or creates and binds it if absent. It fuses `MATCH` and `CREATE` so you can branch on whether the data existed beforehand. It is essential for making daily batches and stream ingestion idempotent. ⚙️ How It Works ・All-or-nothing: `MERGE` operates on the whole pattern—either everything matches or everything is created. It never partially reuses an existing pattern. To mix matching and creating, decompose into multiple `MERGE` clauses. ・`ON CREATE SET` / `ON MATCH SET`: property assignments that run only on create or only on match—handy for creation timestamps or access counters. Both can coexist. ・Merging relationships: at least one endpoint node must already be bound. An undirected `-[r:KNOWS]-` is tried both ways before creating left-to-right. ・Constraints: a uniqueness constraint gives `MERGE` conflict detection and prevents duplicates. For performance, creating an index on the label/property is strongly recommended (without it, every merge scans all nodes). 🛠️ Practical Usage Idempotent upsert over an event stream: ```cypher MERGE (u:User {id: row.userId}) MERGE (p:Page {url: row.url}) MERGE (u)-[v:VIEWED]->(p) ON CREATE SET v.count = 1 ON MATCH SET v.count = v.count + 1 ``` A standard pattern for creating derived nodes without duplicates: ```cypher MATCH (person:Person) MERGE (loc:Location {name: person.bornIn}) MERGE (person)-[r:BORN_IN]->(loc) ON CREATE SET r.createdAt = timestamp() ``` 💡 Use Cases ・Ingesting clickstream/IoT events, deduplicating the same user and page while accumulating counts. ・An ingestion layer where multiple pipelines write master data without ever doubling up entities. ⚠️ Caveats ・Always pair `MERGE` keys with a uniqueness constraint. Without one, concurrent runs can briefly create duplicates (constraints guarantee only eventual consistency). ・`MERGE` rejects `null` property values. Do conditional assignment with a later `SET`. ・You cannot cross-reference a node being created within the same `MERGE`. Match it first, or split into a `SET`. ・`DELETE` fails on a node that still has relationships; use `DETACH DELETE`. #Neo4j# #Cypher#

# Neo4j Features and Practical Usage 🕸️ "If this server goes down, what chain of things stops with it?" Cypher's variable-length patterns answer that by traversing relationships across any number of hops. 🏷️ Title: Variable-length patterns (`*1..5`) / SHORTEST / Quantified Path Patterns 🔗 URL: 📘 Overview Variable-length patterns let you express paths whose hop count is not fixed, all in a single declarative pattern. Questions like "trace suppliers up to 5 levels deep" or "find one shortest path" become natural one-liners. Shortest-path finding and Quantified Path Patterns (QPP) belong to the same family. ⚙️ How It Works ・Quantified relationships (legacy syntax): `[:REL*1..5]` matches 1 to 5 repetitions. `*2` is exactly 2, `*3..` is 3 or more, `*..10` is up to 10, `+` is one or more, and `*` is zero or more. ・Quantified Path Patterns (QPP): wrap a whole pattern in parentheses and quantify it, e.g. `((a)-[r:NEXT]->(b)){1,3}`. It is GQL-conformant and supports inline `WHERE` predicates inside the repetition. ・Group variables: variables declared inside a QPP become lists when referenced outside (e.g. `r` becomes an array of relationships). Combine with `reduce()` to compute, say, total distance along a path. ・Shortest paths: `SHORTEST k` returns k shortest paths, `ALL SHORTEST` returns every tied-shortest path, and `ANY` returns any one. The legacy `shortestPath()` / `allShortestPaths()` functions still work but the keyword syntax is faster. 🛠️ Practical Usage Trace a part's suppliers up to 5 levels deep: ```cypher MATCH (p:Part {sku: $sku})-[:SUPPLIED_BY*1..5]->(supplier:Company) RETURN DISTINCT ``` Find the single shortest introduction chain between two people: ```cypher MATCH path = SHORTEST 1 (a:Person {id:$a})-[:KNOWS]-+(b:Person {id:$b}) RETURN [n IN nodes(path) | AS intro_chain ``` 💡 Use Cases ・Impact analysis: how far a server failure cascades. ・Money-laundering detection: tracing fund-movement paths between accounts. ・Org charts and social graphs: boss-of-boss lookups, friend-of-friend shortest reach. ⚠️ Caveats ・Unbounded `*` or `[:REL*]` causes path explosion and can stall on millions of matches. Always set an upper bound such as `*1..5`. ・Pruning early with labels, relationship types, and inline predicates makes queries dramatically faster. QPP is built for this kind of pruning. ・By default Cypher does not allow re-traversing the same relationship; be aware that this behavior can be modified. #Neo4j# #Cypher#

Neobanks have their best fits in emerging markets. Why? Easy - in those markets, the native currency is often wildly unstable. People want to keep their savings in dollars, but you can't use USD to buy bread. With stablecoin-denominated neobanks, you can.