Neo4j Changelog

What's new in Neo4j 2.2.5

Sep 17, 2015
  • Resolves a critical issue with incremental backups (Neo4j Enterprise), that could result in database inconsistencies after restoring from backup.
  • Resolves a locking issue that could occur in a High Availability deployment (Neo4j Enterprise), which could result in locks being held too long on cluster slaves and resulting is possible deadlock scenarios.
  • Resolved a rare race condition in index lookups, which could result in matched entities not being found by an index lookup.
  • Updates the neo4j import tool to handle the --multiline-field option when importing from CSV.
  • Improved recovery of database statistics after unclean shutdowns, resulting in more accurate statistics.
  • Resolves an issue with recovery of database statistics could fail if large number of indexes are in use.

New in Neo4j 2.2.0 (Mar 26, 2015)

  • A significant release, that provides read and write performance for massive operational throughput — making it our fastest and most scalable graph database yet.
  • Notably, this release includes:
  • A huge facelift to the Neo4j Browser, including many new ways to view and work with your data, including a new graph legend, the ability to terminate cypher queries, curving arrows, panning, visual query plans and much more.
  • A new cost based query planner for Cypher — which is much smarter at planning queries and more transparent about what it’s doing. This compiler is available in addition to the existing rule based compiler and Neo4j will automatically select which to use for each query (this behavior can be adjusted using compiler directives as described in the documentation of cypher query tuning).
  • Full support for profiling and explaining Cypher query plans, including a query plan visualizer in the Neo4j Browser.
  • Username and password authentication for accessing Neo4j. All access to the Neo4j Browser or REST APIs will now need to supply valid credentials. For more detail, see the section on server authentication and authorization in the documentation.
  • A new page cache, which is faster, provides significant improvements in handling of concurrent operations, and is easier to configure than the memory mapping in previous Neo4j releases — now requiring only a single configuration setting (see the configuration documentation for details).
  • Introduces fast-write buffering which dramatically increases the throughput of many write workloads without any configuration required.
  • The use of two separate transactions logs (and associated two phase commit) between the graph and the indexes has been removed, and replaced with a single transaction log. This substantially reduces resource overhead and improves scalability.
  • Many, many fixes improving stability, performance and usability.

New in Neo4j 2.2.0M04 Milestone (Feb 14, 2015)

  • Highly Concurrent Performance:
  • With Neo4j 2.2, we introduce a brand new page cache designed to deliver extreme performance and scalability under highly concurrent workloads. This new page cache helps overcome the limitations imposed by the current IO systems to support larger applications with hundreds of read and/or write IO requirements. The new cache is auto-configured and matches the available memory without the need to tune memory mapped IO settings anymore.
  • Transactional & Batch Write Performance:
  • We have made several enhancements in Neo4j 2.2 to improve both transactional and batch write performance by orders of magnitude under highly concurrent load. Several things are changing to make this happen.
  • First, the 2.2 release improves coordination of commits between Lucene, the graph, and the transaction log, resulting in a much more efficient write channel.
  • Next, the database kernel is enhanced to optimize the flushing of transactions to disk for high number of concurrent write threads. This allows throughput to improve significantly with more write threads since IO costs are spread across transactions. Applications with many small transactions being piped through large numbers (10-100+) of concurrent write threads will experience the greatest improvement.
  • Finally, we have improved and fully integrated the “Superfast Batch Loader”. Introduced in Neo4j 2.1, this utility now supports large scale non-transactional initial loads (of 10M to 10B+ elements) with sustained throughputs around 1M records (node or relationship or property) per second. This seriously fast utility is (unsurprisingly) called neo4j-import, and is accessible from the command line.
  • Cypher Performance:
  • We’re very excited to be releasing the first version of a new Cost-Based Optimizer for Cypher, under development for nearly a year. While Cypher is hands-down the most convenient way to formulate queries, it hasn’t always been as fast as we’d like. Starting with Neo4j 2.2, Cypher will determine the optimal query plan by using statistics about your particular data set. Both the cost-based query planner, and the ability of the database to gather statistics, are new, and we’re very interested in your feedback. Sample queries & data sets are welcome!
  • Despite the strong focus on performance & scalability, we delivered some functional improvements too:
  • Cypher Profiling:
  • As part of work on the Cypher planner, we extended the profiling output in the neo4j-shell. You can now choose to only EXPLAIN or fully PROFILE a query but just prefixing it with one of the keywords. And you can manually select a query planner with CYPHER 2.2-cost and CYPHER 2.2-rule prefixes.
  • Neo4j Browser UI:
  • Many small improvements have been made to the UI, including panning, and the ability to kill a running Cypher query. (Query killing is also supported in the Neo4j Shell using CTRL-C.) Please explore these and tell us what you think of them. The Neo4j Browser also handles long running queries more reliably, which is especially important for imports with LOAD CSV.
  • Basic Authentication:
  • We’ve received requests for a variety of authentication features, and while these are largely planned for the next (Neo4j 2.3) release, we are very pleased to introduce token-based authentication in Neo4j 2.2. This is enabled by default in Neo4j 2.2 M01, which means you must either (a) explicitly disable it in conf/neo4j-server.properties (if you have assured security using another means), or (b) change your app to use the authentication token.
  • We default setting in the milestone release is by design to ensure we get your indispensable feedback!
  • Some things to be aware of:
  • As with all milestones: do not run this in production. This is an early access version to help you prepare for the upcoming production release and provide feedback on the new features. Make sure you refer to the manual for information about new features (especially token-based authentication, neo4j-import, and Cypher optimization and statistics gathering).

New in Neo4j 2.1.5 (Oct 10, 2014)

  • Maintenance release, with critical improvements.
  • Notably, this release addresses the following:
  • Corrects a Cypher compiler error introduced only in Neo4j 2.1.4, which caused Cypher queries containing nested maps to fail type checking.
  • Resolves a critical error, where discrete remove+add operations on properties could result in a new property being added, without the old property being correctly removed.
  • Corrects an issue causing significantly degraded write performance in larger transactions.
  • Improves memory use in Cypher queries containing OPTIONAL MATCH.
  • Resolves an issue causing failed index lookups for some newly created integer properties.
  • Fixes an issue which could cause excessive store growth in some clustered environments (Neo4j Enterprise).
  • Adds additional metadata (label and ID) to node and relationship representations in JSON responses from the REST API.
  • Resolves an issue with extraneous remove commands being added to the legacy auto-index transaction log.
  • Resolves an issue preventing the lowest ID cluster member from successfully leaving and rejoining the cluster, in cases where it was not the master (Neo4j Enterprise).

New in Neo4j 2.1.4 (Sep 11, 2014)

  • Cypher:
  • Reduces memory usage for updating queries, in situations where eager loading of data is not necessary
  • Kernel:
  • Fixes issue with label and property changes, triggered with multiple adds and removes of the same label/property in the same transaction
  • Fixes issue with skipped relationships on transaction rollback
  • Batch importer now properly closes the store on shutdown
  • Upgrading a database no longer affects logging of normal operations
  • Corrects updating of Cache when all relationships of a certain type are removed from a dense node
  • Improves performance of index lookups within a transaction
  • Corrects migration of transaction logs when performing store upgrades from 2.0 and 1.9
  • Fixes race condition between committing and reading threads that might lead to duplicate relationships being returned
  • Consistency check:
  • Consistency checker package is now part of the community bundle
  • Fixes incorrect reports for deleted properties
  • UDC:
  • Disabling UDC through system properties now works as expected
  • HA:
  • Master switches now properly cancel slaves that are transitioning to an obsolete master.
  • Fixes an issue where an instance would report, through JMX, invalid roles for a cluster member
  • Transactions that perform no logical changes will now be properly identified as read only
  • Instances in HA mode will now refuse to start on a store that needs to be upgraded
  • Instances will now check, as part of the cluster join process, if another instance has a store of the same version but upgraded from a store copy that had different transaction count, preventing the possibility of binary incompatible stores participating in the same cluster
  • Starting a HA cluster on an upgraded store will now work as expected, due to logs being upgraded as part of the store upgrade process
  • Backup:
  • Command line tool no longer expects "-from" argument, but "-host" and "-port" instead

New in Neo4j 2.1.2 (Jun 12, 2014)

  • Highlights:
  • Cypher uses indexes for resolving WHERE clauses which use the IN operator
  • Resolves a recovery issue, where multiple forced-restarts in a row, without clean shutdown or log rotation in between, could lead to some transactions not being replayed on recovery
  • Neo4j Browser now defaults to long intervals of heartbeat pings to server, lowering CPU use and network traffic
  • Corrects a critical issue that can occur during migration from previous Neo4j releases, which could lead to incorrect record structures if the previous store had a large volume of deleted data

New in Neo4j 2.1.0 (May 30, 2014)

  • Kernel: Fixes potential leak of transaction state in entity locks that could lead to excess GC activity

New in Neo4j 2.1.0 RC 1 (May 27, 2014)

  • Kernel:
  • The traversal framework can now take Iterable as starting points
  • The Iterable returned from getRelationships(...) can now be iterated more than once
  • Improve the performance of the server by reducing the overhead of logging
  • Further performance improvements for the upgrade process
  • Improve performance by producing less work for the GC in various places
  • Fixes a bug where the transaction log could get duplicate entries, making it unusable for recovery
  • Fixes a bug where the database could leak memory after a mode switch in HA
  • Fixes a bug where file descriptors would leak if more than one MERGE statement was executed in a transaction
  • Fixes a bug where an uncommitted index creation in a transaction could interfer with observing the state of other existing indexes
  • Fixes a bug where old transaction log files could prevent the database from upgrading to a newer version
  • Cypher:
  • To the new planner, added:
  • Select or SemiApply
  • Optional Expand
  • Outer Hash Join
  • Aggregation
  • Skip
  • Limit
  • SortLimit
  • New planner is disabled by default

New in Neo4j 2.0.3 (May 1, 2014)

  • Cypher:
  • MERGE must fail when trying to create 2 nodes with same id but different labels (e.g., MERGE (a: Foo)-[r:KNOWS]->(a: Bar))
  • Allow Cypher split() with empty separator
  • Ensure Cypher range() works with negative step values
  • Kernel:
  • Fixes a deadlock issue in the page cache
  • Fix a transaction log issue where the log could be written to after tx manager marked as NOT_OK.
  • Performance improvements for concurrent reads
  • Cluster:
  • Fixes issue where an instance could revert into SLAVE mode while shutting down.

New in Neo4j 1.9.4 (Sep 26, 2013)

  • Backup:
  • Backup tool and command line utility now exit with status 1 in case the target store has mismatching store ID with the source.
  • Enterprise Server:
  • Properly return UNKNOWN from the HA REST API when the instance is neither master or slave.
  • Cluster:
  • Suspicions on failed instances are now printed only once, no longer spamming messages.log.
  • Fixed issue where a failing cluster instance might delay messages between the rest of the instances.
  • Lucene index:
  • Fixed issue where querying an index for "*:*" while having removed entities from it in the same transaction might result in exceptions.

New in Neo4j 2.0.0 M04 (Aug 14, 2013)

  • New Requirement: Java 7
  • Starting Neo4j with Java 6 will cause errors during startup.
  • Lots of new Math Functions
  • A New Cypher Parser

New in Neo4j 1.9.2 (Jul 19, 2013)

  • Cluster:
  • Fixes bug where a single instance cluster will perpetually try tperform elections
  • Kernel:
  • When flushing persistent windows, dsonly if dirty. This is a performance improvement for certain scenarios.
  • Fixes bug where loading relationship chains with high ids would cause them tbe ignored when iterating over them.
  • Cypher:
  • Fixes problem where Cypher would see changes while the query was running
  • Server:
  • The Content-Type is now correctly used tset the text encoding, not Content-Encoding
  • Fixes concurrency issue with generation of JSON responses
  • HTTPS scheme is now properly propagated on batch requests

New in Neo4j 1.9.1 (Jul 2, 2013)

  • Fixed race condition that could have lead to duplication in the getSingleRelationship() in the Core API.
  • Reduces churn in the resource pool for channels and memory in a clustered environment.
  • Individual pages in paged traversals through the REST API can now be streamed like the other parts of the REST API, see the RESTstreaming docs.
  • SSL certificate chains are supported by the Neo4j server for secure interactions with the REST API

New in Neo4j 2.0.0 M03 (Jun 20, 2013)

  • Kernel:
  • Read-only index results are closed properly
  • Cypher:
  • Make Cypher execution results closable
  • Adds Cypher label scan hint
  • Removes alternative WITH syntax in Cypher
  • Fixes bug with UNION text output
  • Added startNode()/endNode()
  • Fixes #780 - Queries with literal collections fail against schema indexes
  • Server:
  • Added support for transaction keep-alive

New in Neo4j 1.9 RC 2 (May 10, 2013)

  • Backup:
  • Reverts default backup port t6362
  • Cluster:
  • Upgrades tNetty 3.6.3
  • Elections don't start when a quorum is not available, fixing a certain class of race conditions when quorum is lost
  • The joining of an instance is now interpreted as a heartbeat, fixing a class of race conditions when an instance joins and immediately dies
  • Com:
  • Upgrades tNetty 3.6.3
  • Kernel:
  • Fixes race conditions on usage of persistence windows' byte buffers that occasionally led tbuffer over/underflows.
  • Server:
  • Create unique node with properties that have collection values properly casts them tarrays
  • Data visualization editor now navigates back tthe data browser on save and cancel
  • Cypher:
  • Fixes problem when sending down custom queries tindex providers

New in Neo4j 2.0.0 M02 (Apr 26, 2013)

  • In server, added REST transaction support
  • In cypher, added MERGE clause
  • In cypher, MATCH now supports single-node patterns
  • In shell, support for listing indexes and their state
  • Support for labels in the org.neo4j.unsafe.batchinsert APIs.
  • BREAKING CHANGE: Replaced protected fields from org.neo4j.graphdb.factory.GraphDatabaseFactory with a single org.neo4j.graphdb.factory.GraphDatabaseFactoryState instance tavoid race conditions when creating multiple, lazily instantiated builders
  • BREAKING CHANGE: org.neo4j.graphdb.index.BatchInserterIndex and org.neo4j.graphdb.index.BatchInserterIndexProvider has been removed in favor of the same interfaces available in org.neo4j.unsafe.batchinsert
  • BREAKING CHANGE: The BatchInserter and the BatchGraphDatabase are not binary compatible with 1.9 due tsome methods now taking a varargs array of labels as last argument. Please recompile any code that depends on the BatchInserter.

New in Neo4j 1.9 RC 1 (Apr 26, 2013)

  • Lucene Index:
  • Lucene upgraded t3.6.2
  • Server:
  • Introduces new slash screen containing a guide tNeo4j. Several small aesthetic improvements
  • Cypher:
  • Fixed #578 - problem with profiling queries that use LIMIT
  • Fixes #550 - problem when using START after WITH
  • Allows single node patterns in MATCH
  • Fixes problem for some patterns and all-nodes start points
  • Fixes #650 - issue when doing multiple aggregation expressions on the same identifier
  • Added timestamp function
  • Packaging:
  • plugins/ subdirectory is searched recursively for server plugins

New in Neo4j 1.8.2 (Mar 27, 2013)

  • Kernel:
  • Relationship types now use all 16 bits of their address space
  • During recovery start entries now are explicitly marked as written, solving many bugs making startup impossible.
  • Cached nodes have their relationship chain information properly updated on relationship deletes, so traversals will complete successfully even with concurrent modifications from other transactions.
  • Store locking now is respected from read only instances too, removing potential avenues for index corruption.

New in Neo4j 1.9 M05 (Mar 7, 2013)

  • Now compiles and runs under JDK 7
  • Kernel:
  • Concurrent modifications trelationship chains now dnow lead tRecordNotInUse exceptions or cache poisoning
  • Proper tx management will now make negative transaction counts impossible
  • IndexProvider is now deprecated, replaced by KernelExtensionFactory
  • Store locks are respected from read only instances too
  • grab_file_lock configuration setting is now deprecated
  • Lucene Index:
  • LuceneIndexProvider is now replaced by LuceneKernelExtension
  • Server:
  • Added support for X-Forwarded-Host and X-Forwarded-Protheaders tallow parameterising of links in data for hosting behind proxy servers.
  • JMX:
  • JMX will now provide infon all configuration values, including the defaults not explicitly set
  • Cypher:
  • Fixes #450 - Predicates in WHERE are not evaluated correctly for certain patterns
  • Fixes problem with null comparisons and optional relationships
  • Made it possible trun the parser concurrently
  • DISTINCT is now lazy, and keeps the incoming ordering
  • Added execution plan descriptions texecution results
  • Fixes #464 - getDeletedRelationships does not work for javacompat.ExecutionResult
  • Fixes #535 - 'INTERNAL_SORT' columns show when doing RETURN * ORDER BY
  • Added experimental profiled query support
  • Fixes #489 - CREATE UNIQUE does not work as expected inside FOREACH

New in Neo4j 1.9 M04 (Jan 20, 2013)

  • Kernel:
  • Start entries are now explicitly marked as written, solves a bug that might cause recovery to fail
  • Server:
  • Increased performance for rest-batch-operations by a factor of 100
  • Cypher:
  • Clearer error message for when aggregations are used in ORDER BY and not in RETURN
  • Fixes #394 - Identifiers inside of FOREACH get the wrong type
  • Fixes #390 - IN/ANY/NONE/ANY/SINGLE causes RuntimeException for some patterns
  • Fixes #387 - Some patterns produced "Unexpected traversal state" in Cypher
  • Upgraded the Scala version to 2.10
  • Fixes #355 - Collections in collections are still Scala collections instead of Java collections

New in Neo4j 1.9 M03 (Dec 28, 2012)

  • Kernel:
  • We removed an issue with relationship-type-id’s which allows everyone to use the full size of 16 bit aka 65535 different relationship-types now. We also worked on the Java7/OpenJDK support (so far compilation and tests).
  • High Availability:
  • For the new HA mode we improved the logging, added more tests and made it more robust on startup and when clients leave the cluster in order to stabilize the component for Neo4j 1.9.GA.
  • Server:
  • In this milestone, the code for the Tinkerpop integration into the Neo4j Server and its Web-Interface and the Gremlin Plugin has been refactored and centralized. This makes all Tinkerpop dependencies reside only inside that plugin. So it will be possible to support two versions of the Gremlin plugin, one for the 1.5 release and another plugin for the current 2.2.
  • Cypher:
  • Cypher got a lot of internal refactoring, especially around the internal handling of start- and updating clauses and general parse-result representation and management.
  • Our Cypher code has seen some bug fixes, namely around queries that returned non-existant paths https://github.com/neo4j/neo4j/issues/336, substring length limits https://github.com/neo4j/neo4j/issues/369 and updating properties in bulk with SET. We also removed the now obsolete Cypher Plugin that has been deprecated for two releases now.

New in Neo4j 1.8.1 (Dec 28, 2012)

  • Correction of several errors in the parsing and evaluation of Cypher statements.
  • Improvements in the memory footprint of most Cypher statements.
  • Correction of an error in calculating shortest paths that could occur for some graph structures.
  • Improvements in the diagnostic logging required for support provided by Neo Technology.

New in Neo4j 1.9 M1 (Dec 11, 2012)

  • Introduced a simplification of HA cluster operations, and a set of excellent improvements to our query language, Cypher.

New in Neo4j 1.6 M1 (Jul 9, 2012)

  • New:
  • The data browser in Neo4j’s web interface now supports multi-line Cypher queries.
  • CREATE and RELATE can now introduce path identifiers, like this:
  • CREATE p=(n {name:'Miles'})-[:PLAYS]->
  • (m {instrument:'Trumpet'})
  • return p;
  • String literals can now contain some escape characters, like:
  • CREATE (n {text:"single \' and double \" quotes"});
  • Also, these fixes have been incorporated:
  • Fixes #600: Double optional with no matching relationships returns too many rows
  • Fixes #613: Missing dependencies not reported correctly for queries with RELATE/SET/DELETE
  • And some fixes in the handling of optional paths

New in Neo4j 1.6 M1 (Dec 13, 2011)

  • Server logging has been changed, see the Server Configuration chapter in
  • the manual for further information.

New in Neo4j 1.2 M6 (Dec 22, 2010)

  • Kernel:
  • Fixed an issues with PruneEvaluators getting invoked with the start node as argument.
  • PruneEvaluators was never invoked with the start node before the arrival of Evaluator interface.
  • Added logging of recovery completion.
  • Added TransactionData#isDeleted(Node) and #isDeleted(Relationship) and alsmade
  • the collection thold these a HashSet instead of ArrayList. This allows fast
  • lookups for asking if a node/relationship is deleted in a transaction.
  • More flexible caching (can instantiate an arbitrary Cache object).
  • Shell:
  • Fixed a problem where ShellServerExtension assumed the shell was enabled during shutdown, which could result in NPE.
  • Lucene-index:
  • More flexible caching (can instantiate an arbitrary Cache object).
  • Merged the fast-writes branch. Basically it makes committing changes tlucene indexes
  • faster and more throughput-friendly for multiple threads. The performance improvement
  • for committing lucene transactions shows best for small transactions, but will improve
  • all modifying operations tlucene indexes.
  • Fixed bug which could close an IndexSearcher before it was supposed twhen
  • there was exactly one item in the result set, twor more threads did this at
  • the same time as there was another thread doing an update... AND the reading
  • threads all called IndexHits#getSingle() on the result.
  • HA:
  • When a new master is chosen, slaves throws away the id allocations they got from the previous master. This fixes a problem where occupied ids where reused.
  • Enabled (and fixed problem with) thread on master which checks for dead slave connections and rolls back those transactions, sthat their locks are released.
  • This fixes a problem where an HA cluster would seem tfreeze up and become unresponsive twrite requests.
  • Adding Log4j and Netty license information.
  • Alscloses the executor containing the connections.
  • Changed dependency scopes.
  • Shuts down databases after verifying them.
  • Server:
  • Bridge OSGi LogService tserver Logger. Bundle log messages and stdout pipe through correctly.
  • Refactoring of functional tests tremove static dependencies. Introduced a server builder tdeal with it instead.
  • Can now add performance-tweaking properties tthe database hosted by the server. It uses the same neo4j.properties file as the embedded version, but you need tadd a property:
  • org.neo4j.server.db.tuning.properties intthe neo4j-server.properties file.
  • Webadmin: Removed component titles, added save button tdata browser, minor change tdata browser layout.
  • Webadmin: Minor UI updates, added error message that shows up when server connection is lost.
  • Webadmin: Moved charts inttabbed box, minor UI updates.
  • Fixed an issue with initialization order of things in the server tmake sure that RRD is initialized when it is needed.
  • Webadmin: Added proper tab-like styling tchart tabs and scale selectors.
  • Fixed bug in RRD memory usage sampler, making rounding happen at end of calculations, instead of in the midst of.
  • Webadmin: Made 30minutes the default view in charts.
  • Webadmin: Added kernel version tdashboard, fixed bug in chart drawing (was drawing when the charts are not visible under certain conditions).
  • Webadmin: Disallow self relationships in UI, and show error message explaining this.
  • Can now load 3rd party JAX-RS jars from the classpath.
  • Updated static assembly tproperly include both webadmin statics and documentation. Documentation now tested and ships properly down tneo4j-standalone.
  • Webadmin: Made the current node show up by default when adding new relations in webadmin.
  • Webadmin: Dashboard shows charts with tabs, and allows switching between charts.
  • Added a basic readme with instructions for building, running, and functional testing.
  • Updating the way tcreate temporary files tsolve the functional test problem where lots of files stick around.
  • re-implemented REST texpose indexing of nodes and relationships (new index API)
  • single path algworks in RestfulGraphDatabase now
  • fixed duplicate paths for delete node or relationship from index
  • Http DELETE requires the proper mediatype taccept
  • All indexes must be created tuse them.
  • Added the ability extend the REST API with server plugins.
  • Added back links tthe first page in the HTML format.
  • updating tGremlin 0.6
  • Updated the component site documentation with the new index API.

New in Neo4j 1.2 M5 (Dec 4, 2010)

  • New components:
  • neo4jha, providing high availability
  • Important changes, server:
  • updated tJersey 1.4
  • integrated index is now supported by the shell
  • new Evaluator interface improves the traversal API
  • support for index hit scores in neo4jluceneindex
  • index caching support added tBatchInserter

New in Neo4j 1.2 M4 (Nov 23, 2010)

  • added a server packaging as part of neo4j
  • added more configuration options to neo4j-lucene-index
  • generating javadocs for all components automatically to components.neo4j.org/{component-name}
  • Added ImpermanentGraphDatabase to aid in testing

New in Neo4j 1.2 M2 (Nov 9, 2010)

  • Monitoring/management over JMX was moved to the neo4j-management component.
  • API
  • Added ability to get the names of existing integrated indexes:
  • Index#getName() and Index#getConfiguration()
  • IndexManager#nodeIndexNames() and #relationshipIndexNames()
  • Added utility to expand traversals using a relationship type in any direction:
  • Traversal.expanderForTypes(RelationshipType)

New in Neo4j 1.2 M1 (Oct 13, 2010)

  • Kernel extensions additional services for the Neo4j Kernel are loaded
  • automatically if they are present on the classpath.
  • The ability tinject Kernel extensions in a running instance through JVM
  • agents. This is used for loading the shell on an running instance.
  • API
  • Traversal: Uniqueness is now instantiated through a factory, with
  • the previous enum (moved torg.neo4j.kernel) as default implementation.
  • Filters in a traversal description are additive (just as PruneEvaluators).
  • Bug fixes
  • Circumvented the fact that Class.forName() sometimes throws a
  • NoClassDefFoundError instead of ClassNotFoundException.
  • Optimizations
  • NodeImpl/RelationshipImpl takes less memory since they nlonger have
  • reference tNodeManager.
  • Fixed some lowlevel throughput/concurrency issues.
  • Added (default) weak reference cache option. Control with f.ex. "cache_type=weak"

New in Neo4j 1.1 (Jul 31, 2010)

  • New features
  • Auto configuration by looking at available RAM and heap.
  • New event framework, see http://wiki.neo4j.org/content/Event_framework
  • JMX enabled kernel.
  • New traversal framework, see http://wiki.neo4j.org/content/Traversal_Framework
  • Block size for strings and arrays are now configurable when creating a new db.
  • Read only operations can now execute without a transaction.
  • API
  • Added a method to get the GraphDatabaseService on Node and Relationship.
  • Moved the commons component utilities into kernel component,
  • see helpers package.
  • Bug fixes
  • Fixed issues with logical log and active log that could cause recovery
  • to throw an exception.
  • Fixed buffer overflow for large string/array properties.
  • Fixed bug that could cause leak of NodeImpl.

New in Neo4j 1.0 (Feb 17, 2010)

  • Updated javadoc.
  • Bug fixes o Fixed leak of non committed property changes to other transactions. o Fixed cache duplication bug of relationships.
  • Fixed problem that could cause other exception to be thrown than NotFoundException on getNodeById/RelationshipById.
  • Fixed problem with recovery when LuceneFulltextIndex entries existed in global transaction log.
  • BatchInserter now throws exception when trying to create a relationship with same start and end node.
  • Fixed problem with broken entries in logical log that could cause recovery to throw an exception

New in Neo4j 1.0 RC (Jan 13, 2010)

  • API: moved API to org.neo4j.grapdb and implementation to org.neo4j.kernel.impl

New in Neo4j 1.0 Beta 11 (Dec 28, 2009)

  • Minor Enhancements, changes and tweaks o Removed compile-time dependency on shell component.
  • Batch inserter now has a NeoService version.
  • Minor tweak of concurrency characteristics of array map implementation.
  • Bug fixes o Fixed problem with half entries in global tx log (due to full disk).
  • Fixed some bugs in batch inserter

New in Neo4j 1.0 Beta 10 (Nov 3, 2009)

  • Enhancements, new features and major changes
  • Core: Read-only mode. It is now possible to start multiple read only
  • NeoServices to the same store (using EmbeddedReadOnlyNeo).
  • Core: Improved depth first traversal speed on nodes with many
  • relationships by loading relationships on demand. This will also
  • reduce the stress on GC when traversing over a node with many
  • relationships since much fewer objects will be created.
  • Minor enhancements, changes and tweaks
  • Core: Faster rebuild of id generators after a crash
  • Core: Exception cleanup removing bad code either catching Throwable or
  • throwing RuntimeException.
  • core: Fixed so a read only NeoService can apply a logical log from a
  • backup.
  • Bug Fixes
  • Fixed a bug when using plain buffers instead of memory mapped ones that
  • could case recovery to fail due to buffers not being flushed properly.

New in Neo4j 1.0 Beta 9 (Oct 14, 2009)

  • Enhancements:
  • Core: New 'batch insert' mode, see http://wiki.neo4j.org/content/Batch_Insert,
  • typically used for initial import of bulk data.
  • Core: Added a "Windows mode" that uses plain Java buffers instead of mmap().
  • Core: Expanded id space for all primitives by adding one more bit.
  • Core: Read only transactions have been optimized to have much less overhead.
  • Core: New cache implementation based on soft references, which employs faster
  • gets and is more concurrent and memory efficient.
  • Core: OSGi enabled [thanks Andreas Kollegger]
  • Minor enhancements, changes and tweaks:
  • Shell: Added a traverser command for creating custom traversers.
  • Shell: Added support of setting and listing array types.
  • Shell: "cd" command can now position itself on a relationship.
  • Shell: Output of "man" command has been improved.
  • Bug fixes:
  • Core: Fixed all known batch inserter bugs.
  • Core: Fixed a bug that could cause multiple remove of same property to fail
  • (should just return null if it doesn't exist).

New in Neo4j 1.0 Beta 7 (Jan 19, 2009)

  • API: Removed a number of deprecated methods (primarily for relationship type management) from EmbeddedNeas per warning in the previous release.
  • API: Transaction is now an interface.
  • API: TraversalPosition now has an isStartNode() method.
  • API: NotFound and NotInTransaction runtime exceptions have been moved from internal impl package tthe api package.
  • API: getRelationshipById is now exposed in NeoService.
  • API: A common base interface for Node and Relationship has been added that contains the set/get/remove property operations.
  • Core: Made it easy tembed Neo4j in a Spring application. Spring can alsbe configured tuse Neo4j's transaction manager.
  • Core: All known bugs have been fixed.
  • Core: Removed singletons and made everything IoC.
  • Core: Lots of minor optimization and improvements above native store layer (nioneo).
  • Core: Cleanup of code (removed non used code) and improved exception handling.
  • Core: Improved read performance and parallelism by implementing MVCC-like features. Nlocks are now taken during read-only operations, instead concurrent operations are working against snapshot versions. Rather than full versioning, for higher performance diffs are kept and applied tthe right transactions (those that have modified data). Result is that read operations will execute taking nlocks, make full use of what has already been cached and can execute concurrently with a transaction that modify the same data. Write operations will take locks and use diffs instead of full copy on write (this proved tbe faster and scale better than actually doing a in memory copy of the required data).