| TinkerPop3 CHANGEGLOG |
| ===================== |
| |
| TinkerPop 3.0.0 (A Gremlin Rāga in 7/16 Time) |
| --------------------------------------------- |
| |
| image::http://www.tinkerpop.com/docs/current/images/gremlin-hindu.png[width=225] |
| |
| TinkerPop 3.0.0.M4 (Release Date: NOT OFFICIALLY RELEASED YET) |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| * Added features for `VertexProperty` user supplied ids and related data types. |
| * Removed `SideEffectCap` marker interface as there is only one `SideEffectCapStep` and thus, `instanceof` is sufficient. |
| * `Path.getObjects()`/`Path.getLabels()` renamed to `Path.objects()`/`Path.labels()` to be in line with "query language" naming convention. |
| * Greatly simplified `GiraphInternalVertex` due to `Element.graph()` -- 1/2 the memory footprint and reduced construction time. |
| * Renamed `Property.getElement()` to `Property.element()` given the "query language" naming convention. |
| * `Element.graph()` added which returns the `Graph` that the element is contained within. |
| * Added tests for greater consistency around iterating hidden properties. |
| * Simplified `TraversalVertexProgram` where only a single `TraverserTracker` exists for both path- and simple-traversers. |
| * Fixed a major bug where `Arrays.binarySearch` was being used on an unsorted array in TinkerGraph and Neo4jGraph. |
| * Changed `ComputerResult.getXXX()` to `graph()` and `memory()` to be consistent with "query language" naming convention. |
| * `Traverser.getXXX()` changed to `loops()`, `bulk()`, `path()`, `sideEffects()` to be consistent with "query language" naming convention. |
| * Optimization to reduce the number of empty lists created due to no step class existing for respective `TraversalStrategy.apply()`. |
| * Added `CapTraversal` as a marker interface for the `cap()` method. |
| * Added `union()` with GraphComputer `UnionLinearStrategy`. |
| * `TimeLimitStep` was moved to `filter/` package. It was a mistake that it was in `sideEffect/`. |
| * Provided the configuration for generating both a "full" and "core" set of javadocs, where "full" represents all classes in all projects and "core" is the "user" subset. |
| * Validated bindings passed to Gremlin Server to ensure that they do not match the most common statically imported values. |
| * If no script engine name is provided to a `LambdaHolder` it is assumed to be Gremlin-Groovy. |
| * `MapEmitter` and `ReduceEmitter` have an `emit(value)` default method where the key is the `MapReduce.NullObject` singleton. |
| * `Traverser.Admin` now implements `Attachable` as the `Traversal.SideEffects` can be generated from the `Vertex`. |
| * Made a solid effort to ensure that all TinkerPop keys are `Graph.System` to leave `Graph.Key` for users. |
| * The `Graph.System` prefix is now `^` instead of `%&%`. Simpler and easier on the `toString()`-eyes. |
| * Added `Traversal.SideEffects.ifPresent(Consumer)` as a default helper method. |
| * Added `profile()`-step which provides detailed information about the performance of each step in a traversal. |
| * No more `CountCapStep` and `CountStep`, there is only `CountStep` and it is elegant. |
| * Created a `AbstractTraversalStrategy` with good `toString()`, `hasCode()`, and `equals()` implementations. |
| * Added `CountTraversal` as a marker-interface stating that the `Traversal` has a `count() -> Long` method. |
| * `Traversal` no longer has any step methods as its not required for DSL implementers to have "core steps." |
| * Added "linearization" strategy for `ChooseStep` so it is executed correctly on GraphComputer. |
| * Added ``GraphTraversalStrategyRegistry` which has respective global strategies to make turning on/off strategies easier. |
| * Added a generic `BranchStep` to be used for re-writing "meta-steps" for execution on GraphComputer. |
| * Moved `JumpStep`, `UntilStep`, and `ChooseStep` to a new `branch/` package. |
| * Added test cases to the Structure Suite to enforce consistent operations of reading properties after removal of their owning `Element`. |
| * GraphSON format change for full `Graph` serialization - Graph variables are now serialized with the key "variables" as opposed to "properties". |
| * Relaxed `Graph.toString()` test requirements for implementers. |
| * Made the `toString` operations in `GraphStrategy` consistent. |
| * Added `VertexFeatures.supportsRemoveProperty`. |
| * Added `VertexPropertyFeatures.supportsRemoveProperty`. |
| * Added `EdgeFeatures.supportsRemoveProperty`. |
| * Added `VertexFeatures.supportsRemoveVertices`. |
| * Added `EdgeFeatures.supportsRemoveEdges`. |
| * Vendors should now get a clear error when mis-spelling something in an `@OptOut` (or more likely if a test name changes) and it now works all the test suites. |
| * All plugins now have a default prefix of "tinkerpop." as a namespace. |
| * `GraphComputer` now executes a `Set<MapReduce>` and `hashCode()`/`equals()` were implemented for existing `MapReduce` implementations. |
| * Changed `Contains.in/notin` to `Contains.within/without` as `in` is a reserved term in most languages (including Java and Groovy). |
| * Added helper methods for loading data into collections in `TraversalHelper`. |
| * Core `Traversal` methods are smart about bulking -- e.g. `iterate()`, `fill()`, `remove()`, etc. |
| * `GroupByStep` and `GroupByMapReduce` leverage `BulkSet` as the default group data structure. |
| * `Element.Iterator` has renamed methods so implementers can do `MyElement implements Element, Element.Iterators`. |
| * Renamed `MessageType.Global` and `MessageType.Local` creators from `of()` to `to()` as it makes more sense to send messages `to()`. |
| * With `Traverser.get/setBulk()` there is no need for a `TraverserMessage`. The `Traverser` is now the message in `TraversalVertexProgram`. |
| * Provided static `make()` methods for constructing `Path` implementations. |
| * Provided a more space/time efficient algorithm for `Path.isSimple()`. |
| * The `JumpStep` GraphComputer algorithm `Queue` is now a `TraverserSet`. |
| * `AggregateStep` and `StoreStep` now use `BulkSet` as their default backing `Collection` (much more space/time efficient). |
| * Added `BulkSet` which is like `TraverserSet` but for arbitrary objects (i.e. a weighted set). |
| * `UnrollJumpStrategy` is no longer a default strategy as it is less efficient with the inclusion of `TraverserSet`. |
| * Introduced `TraverserSet` with bulk updating capabilities. Like OLAP, OLTP looping is now linear space/time complexity. |
| * TinkerGraph's MapReduce framework is now thread safe with a parallel execution implementation. |
| * Added a default `Traverser.asAdmin()` method as a typecast convenience to `Traverser.Admin`. |
| * Renamed `Traverser.System` to `Traverser.Admin` as to not cause `java.lang.System` reference issues. |
| * Renamed `Memory.Administrative` to `Memory.Admin` to make it shorter and consistent with `Traverser.Admin`. |
| * Fixed a TinkerGraph bug around user supplied vertex property ids. |
| * Most `Step` classes are now defined as `public final class` to prevent inheritance. |
| * `ShuffleStep` now extends `BarrierStep` which enables semantically correct step-sideEffects. |
| * Leveraged `Traverser.getBulk()` consistently throughout all steps. |
| |
| TinkerPop 3.0.0.M3 (Release Date: October 6, 2014) |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| * All `Step` fields are now `private`/`protected` with respective getters as currently needed and will be added to as needed. |
| * Gremlin Server no longer has the `traverse` operation as lambdas aren't really serialized. |
| * `Path` is now an interface with `ImmutablePath` and `MutablePath` as implementations (2x speedup on path calculations). |
| * `Traverser` now implements `Comparable`. If the underlying object doesn't implement `Comparable`, then a runtime exception. |
| * Added abstract `BarrierStep` which greatly simplifies implementing barriers like `AggregateStep`, `OrderStep`, etc. |
| * `SelectStep` is now intelligent about when to trigger path computations based on label selectors and barriers. |
| * `T` no longer has `eq`, `neq`, `lt`, `in`, etc. Renamed all respective enums and with `static import`, good in console (e.g. `Compare.eq`). |
| * Added `Order` enum which provides `Order.decr` and `Order.incr`. |
| * `Traverser.loops` and `Jump.loops` are now shorts (`32767` max-loops is probably sufficient for 99.9999% of use cases). |
| * `Traverser.bulk` exists which is how many instances does the traverser represent. For use in grouping with bulk computations. |
| * Greatly simplified sideEffect steps where there is no distinction between OLAP vs. OLTP (from the `Step` perspective). |
| * Removed the need for `Bulkable` and `VertexCentric` marker interfaces in process API. |
| * Renamed configuration parameters in Giraph-Gremlin to be consistent with a `giraph.gremlin`-prefix. |
| * Made it possible to pass a `ScriptEngine` name and string script in `TraversalVertexProgram` and `LambdaVertexProgram`. |
| * Made `TinkerGraph` a plugin for the Console as it is no longer a direct dependency in `gremlin-groovy`. |
| * Added features for supporting the addition of properties via `Element.property(String,Object)`. |
| * `GiraphGraph` OLTP tested against Gremlin-Java8 and Gremlin-Groovy -- OLAP tested against Gremlin-Groovy. |
| * `Neo4jGraph` is now tested against both Gremlin-Java8 and Gremlin-Groovy. |
| * Renamed the test cases in `ProcessTestSuite` to be consistent with other Gremlin language variants. |
| * Add a `gremlin-groovy-test` suite that can be used to validate implementations against the Groovy variant of Gremlin. |
| * `TinkerGraph` is no longer serializable, use a `GraphReader`/`GraphWriter` to serialize the graph data. |
| * Removed `implements Serializable` on numerous classes to ensure safety and proper usage of utilities for cloning. |
| * `Traversal` now implements `Cloneable` as this is the means that inter-JVM threads are able to get sibling `Traversals`. |
| * Created "integration" test for `Neo4jGraph` that runs the test suite with multi/meta property features turned off. |
| * Added `GraphStrategy` methods for `VertexProperty`. |
| * Converted the `id` data type from string to integer in the Grateful Dead sample data. |
| * Removed all notions of serializable lambdas as this is a misconception and should not be part of TinkerPop. |
| * Greatly simplified `TraversalVertexProgram` with three arguments: a `Traversal<Supplier>`, `Class<Traversal<Supplier>>`, or a script string with `ScriptEngine` name. |
| * Added `TraversalScript` interface with `GroovyTraversalScript` as an instance. To be used by OLAP engines and any language variant (e.g. gremlin-scala, gremlin-js, etc.). |
| * `UntilStep` now leverages `UnrollJumpStrategy` accordingly. |
| * Fixed a bug where the `toString()` of `Traversal` was being hijacked by `SugarGremlinPlugin`. |
| * Fixed compilation bug in `UntilStep` that is realized when used in multi-machine OLAP. |
| * Simplified `Enumerator` and implementations for `MatchStep`. |
| |
| TinkerPop 3.0.0.M2 (Release Date: September 23, 2014) |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| * Added an exhaust `InnerJoinEnumerator` fix in `MatchStep` to get all solutions correctly. |
| * `Neo4jGraph` can be configured to allow or disallow meta- and multi-properties. |
| * Added `until()`-step as a simpler way to express while-do looping which compiles down to a `jump()`-step equivalent. |
| * Added "The Crew" (`CREW`) toy graph which contains multi-properties, meta-properties, graph variables, hiddens, etc. |
| * If the Giraph job fails, then the subsequent `MapReduce` jobs will not execute. |
| * Added `Graph.System` class which generates keys prefixed with `%&%` which is considered the vendor namespace and not allowed by users. |
| * Added `ReferencedVertex` (etc. for all graph object types) for lightweight message passing of graph object ids. |
| * `T.*` now has `label`, `id`, `key`, `value` and no longer are these `String` representations reserved in TinkerPop. |
| * `Traverser` now has a transient reference to `Traversal.SideEffects`. |
| * "Detached" classes are now tested by the standard test suite. |
| * Compartmentalized `Traverser` interface so there is now a `Traverser.System` sub-interface with methods that users shouldn't call. |
| * Added `OrderByStep` which orders `Elements` according to the value of a provided key. |
| * 2x speed increase on steps that rely heavily on `ExpandableStepIterator` with massive memory footprint reduction as well. |
| * Added `VertexProperty<V>` as the property type for vertices -- provides multi-properties and properties on properties for vertices. |
| * Changed `VertexProgram` such that `getElementComputeKeys()` is simply a `Set<String>`. |
| * Significant changes to the format of the `ResponseMessage` for Gremlin Server - these changes break existing clients. |
| * Close any open transactions on any configured `Graph` when a session in Gremlin Server is killed. |
| * Grateful Dead Graph now uses vertex labels instead of "type" properties. |
| * There is now a `GraphComputerStrategy` and `EngineDependent` marker interface to allow steps to decide their algorithm depending if they are OLAP or OLTP. |
| * A labeled step now stores its current traverser value in `Traversal.SideEffects` (no longer can sideEffectKeys and step labels be the same). |
| * `GraphFactory` support for opening a `Graph` with multiple `GraphStrategy` instances - if there are multiple strategies they are wrapped in order via `SequenceGraphStrategy`. |
| * The result type for result termination messages returned from Gremlin Server is now set to "no content". |
| * The `maxContentLength` setting for Gremlin Driver now blocks incoming frames that are too large. |
| * After initialization scripts are executed in Gremlin Server, the `Graph` instances are re-bound back to their global references, thus allowing `GraphStrategy` initialization or even dynamic `Graph` creation through scripts. |
| * Added "Modern" graph back which is basically the "Classic" graph with double values for the "weight" property on edges and non-default vertex labels. |
| * `Traversal.addStep()` is now hard typed so type casting isn't required and traversal APIs look clean. |
| * Changed the hidden key prefix from `%$%` to `~` in `Graph.Key.hide()`. |
| * Added `has(label,key,predicate,value)` to allow for `has('person','name','marko')`. Various overloaded methods provided. |
| * Update to traversal API where if a `SFunction<S,?>` was required, but can process a `Traverser<S>`, then the function is `SFunction<Traverser<S>,?>`. |
| * Added `WhereStep` as a way to further constrain `select()` and `match()`. |
| * Extensive work on `GiraphMemory` and its interaction with Giraph aggregators. |
| * If the input path of a `GiraphGraphComputer` does not exist, failure happens prior to job submission. |
| * `SugarPlugin` now has all inefficient methods and Gremlin-Groovy proper is only efficient Groovy techniques. |
| * Prevent concurrency problems by only modifying bindings within the same thread of execution in the `GremlinExecutor`. |
| * Calls to `use` on the `DependencyManager` now return the list of `GremlinPlugin` instances to initialize instead of just initializing them automatically because it causes problems with `ScriptEngine` setup if a plugin requires a script to be evaluated and a required dependency is not yet loaded. |
| * `Traversal.SideEffects` has `getGraph()`, `setGraph()`, and `removeGraph()` default helpers. |
| * `Traversal.Memory` -> `Traversal.SideEffects` and `GraphComputer.SideEffects` -> `GraphComputer.Memory`. |
| * `StrategyWrappedVertex` and `StrategyWrappedEdge` properly wrap `Element` objects returned from non-traversal based methods. |
| * Gremlin-Server now sends a single write with status 200 for Object and empty response messages. |
| * `GremlinGroovyScriptEngine` allows imports to re-import dependencies added via "use". |
| * Changed order in which the `GremlinExecutor` is initialized such that dependency loading via "use" are handled first which fixes problems with starting Gremlin Server with `gremlin-server-neo4j.yaml`. |
| * Corrected issues with the "branch factor" related traversals under `SubgraphStrategy`. This change also altered the semantics of the `SubgraphStrategy` a bit as it became more restrictive around `Edge` inclusion (requires both vertices to be in the subgraph). |
| * The Gephi Plugin now visualizes traversals and has numerous configuration options. |
| * Add more specific features around the types of "identifiers" a graph can support. |
| * Add a new test graph called `MODERN` that is copy of the `CLASSIC` graph, but represents floats as doubles. This graph will be the default graph for testing going forward. |
| * Fix bug in `Neo4jGraph` that was not processing multiple vertex labels properly when doing a `has()` step with `IN`. |
| * Changed semantics of `@LoadGraphWith` in gremlin-test to only refer to the ability of a test implementation to process the data types of the test graph (not to actually load it). |
| * `StartStep` is a `SideEffect` as it is a process to get data into the stream (like a keyboard) and more efficient as such. |
| * Greatly simplified the implementations of `Map`, `FlatMap`, `Filter`, and `SideEffect`. |
| * `Path` data structure changed to an ordered list of objects with each associated to a `Set<String>` of as-labels. |
| * All sideEffect-based steps no longer extend `FilterStep` with predicate equal true, but a more efficient `SideEffectStep`. |
| * `TreeStep` now has `TreeMapReduce` for executing on `GraphComputer`. |
| * `Neo4jTraversal.cypher()` is fluent throughout. |
| * Reverted back to TP2 model of `as()` referring to step names, not variable names of sideEffects. |
| * Updated `AddEdge`-step to support property key/value pairs for appending to newly created edges. |
| * Renamed `Graph.getFeatures()` to `Graph.features()` to be consistent with other API methods. |
| * `Vertex` and `Edge` now implement all `GraphTraversal` methods to ensure consistency throughout stack. |
| * `Neo4jTraversal` is auto-generated from `Neo4jTraversalStub` with technique generalizable to other vendors. |
| * Added test suite to ensure that all traversals are of the same type: `g.V`, `g.E`, `g.of()`, `v.identity()`, `e.identity()`, v-, e-methods. |
| * Giraph HDFS helpers now support `hdfs.mkdir(string)` and `local.mkdir(string)` |
| * Added `@OptIn` and `@OptOut` for implementers to specify on their `Graph` implementations for test compliance information. |
| * `GraphComputer` `Memory` now immutable after computation is complete. |
| * Dependency grabbing for plugins filter out slf4j logging dependencies so as to avoid multiple bindings with the standard TinkerPop distributions. |
| * Fixed `GiraphMemory` to be fully consistent with GraphComputer specification. |
| * Removed fatJar assembly from Giraph-Graph as it is no longed needed with distributed cache model. |
| * Reworked `GiraphRemoteAcceptor` to provide a `result` variable back to the console with `ComputerResult`. |
| * `VertexProgram` is not longer `Serializable` (use `loadState` and `storeState` for wire-propagation). |
| * Moved `GiraphGraph.getOutputGraph()` to `GiraphHelper`. |
| * Changed `GIRAPH_GREMLIN_HOME` to `GIRAPH_GREMLIN_LIB` to reference directory where jars are to be loaded. |
| * Updated README with release instructions. |
| |
| TinkerPop 3.0.0.M1 (Release Date: August 12, 2014) |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| * First official release of TinkerPop3 and thus, no changes. |
