You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2020/09/11 21:21:02 UTC
[tinkerpop] branch TINKERPOP-2054 created (now d3f3084)
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a change to branch TINKERPOP-2054
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git.
at d3f3084 TINKERPOP-2054 Added traversalstrategy support to Javascript
This branch includes the following new commits:
new d3f3084 TINKERPOP-2054 Added traversalstrategy support to Javascript
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[tinkerpop] 01/01: TINKERPOP-2054 Added traversalstrategy support
to Javascript
Posted by sp...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch TINKERPOP-2054
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit d3f308467c6a87a817ae4bd0be39529ce18d8644
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Fri Sep 11 15:56:11 2020 -0400
TINKERPOP-2054 Added traversalstrategy support to Javascript
---
CHANGELOG.asciidoc | 3 +-
docs/src/upgrade/release-3.4.x.asciidoc | 13 +
.../glv/GraphTraversalSource.template | 4 +-
.../lib/process/graph-traversal.js | 4 +-
.../lib/process/traversal-strategy.js | 279 +++++++++++++++++++--
.../test/integration/traversal-test.js | 46 +++-
.../test/unit/translator-test.js | 3 -
7 files changed, 324 insertions(+), 28 deletions(-)
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index 2f5b903..37df276 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -31,7 +31,8 @@ image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
* Deprecated `withGraph()` in favor of `withEmbedded()` on `AnonymousTraversalSource`.
* Fixed bug in Javascript `Translator` that wasn't handling child traversals well.
* Fixed an iterator leak in `HasContainer`.
-* Avoid creating unnecessary detached objects in JVM
+* Avoid creating unnecessary detached objects in JVM.
+* Added support for `TraversalStrategy` usage in Javascript.
* Added `Traversal.getTraverserSetSupplier()` to allow providers to supply their own `TraverserSet` instances.
[[release-3-4-8]]
diff --git a/docs/src/upgrade/release-3.4.x.asciidoc b/docs/src/upgrade/release-3.4.x.asciidoc
index 9359e07..a1bf501 100644
--- a/docs/src/upgrade/release-3.4.x.asciidoc
+++ b/docs/src/upgrade/release-3.4.x.asciidoc
@@ -57,6 +57,19 @@ to use `withRemote()` variants).
See: link:https://issues.apache.org/jira/browse/TINKERPOP-2413[TINKERPOP-2413]
+==== TraversalStrategy in Javascript
+
+Using `SubgraphStrategy`, `PartitionStrategy` and other `TraversalStrategy` implementations is now possible in
+Javascript.
+
+[source,javascript]
+----
+const sg = g.withStrategies(
+ new SubgraphStrategy({vertices:__.hasLabel("person"), edges:__.hasLabel("created")}));
+----
+
+See: link:https://issues.apache.org/jira/browse/TINKERPOP-2054[TINKERPOP-2054]
+
=== Upgrading for Providers
==== Graph System Providers
diff --git a/gremlin-javascript/glv/GraphTraversalSource.template b/gremlin-javascript/glv/GraphTraversalSource.template
index 80476f1..fc55316 100644
--- a/gremlin-javascript/glv/GraphTraversalSource.template
+++ b/gremlin-javascript/glv/GraphTraversalSource.template
@@ -71,7 +71,9 @@ class GraphTraversalSource {
* @returns {GraphTraversalSource}
*/
withComputer(graphComputer, workers, result, persist, vertices, edges, configuration) {
- return this.withStrategies(new VertexProgramStrategy(graphComputer, workers, result, persist, vertices, edges, configuration));
+ return this.withStrategies(new VertexProgramStrategy({graphComputer: graphComputer,
+ workers: workers, result: result, persist: persist, vertices: vertices, edges: edges,
+ configuration: configuration}));
}
/**
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
index efa097b..b0e91f2 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
@@ -71,7 +71,9 @@ class GraphTraversalSource {
* @returns {GraphTraversalSource}
*/
withComputer(graphComputer, workers, result, persist, vertices, edges, configuration) {
- return this.withStrategies(new VertexProgramStrategy(graphComputer, workers, result, persist, vertices, edges, configuration));
+ return this.withStrategies(new VertexProgramStrategy({graphComputer: graphComputer,
+ workers: workers, result: result, persist: persist, vertices: vertices, edges: edges,
+ configuration: configuration}));
}
/**
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal-strategy.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal-strategy.js
index 2e234d9..301eb07 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal-strategy.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/traversal-strategy.js
@@ -22,8 +22,6 @@
*/
'use strict';
-const utils = require('../utils');
-
class TraversalStrategies {
/**
* Creates a new instance of TraversalStrategies.
@@ -61,6 +59,15 @@ class TraversalStrategies {
class TraversalStrategy {
/**
+ * @param {String} fqcn fully qualified class name in Java of the strategy
+ * @param {Map} configuration for the strategy
+ */
+ constructor(fqcn, configuration = new Map()) {
+ this.fqcn = fqcn;
+ this.configuration = configuration;
+ }
+
+ /**
* @abstract
* @param {Traversal} traversal
* @returns {Promise}
@@ -70,32 +77,266 @@ class TraversalStrategy {
}
}
+class ConnectiveStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ConnectiveStrategy");
+ }
+}
+
+class ElementIdStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.ElementIdStrategy");
+ }
+}
+
+class HaltedTraverserStrategy extends TraversalStrategy {
+
+ /**
+ * @param {String} haltedTraverserFactory full qualified class name in Java of a {@code HaltedTraverserFactory} implementation
+ */
+ constructor(haltedTraverserFactory) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.HaltedTraverserStrategy");
+ if (haltedTraverserFactory !== undefined)
+ this.configuration.set("haltedTraverserFactory", haltedTraverserFactory);
+ }
+}
+
+class OptionsStrategy extends TraversalStrategy {
+ constructor(options = new Map()) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy", options);
+ }
+}
+
+class PartitionStrategy extends TraversalStrategy {
+ /**
+ * @param {Object} [options]
+ * @param {String} [options.partitionKey] name of the property key to partition by
+ * @param {String} [options.writePartition] the value of the currently write partition
+ * @param {Array<String>} [options.readPartitions] list of strings representing the partitions to include for reads
+ * @param {boolean} [options.includeMetaProperties] determines if meta-properties should be included in partitioning defaulting to false
+ */
+ constructor(options) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.PartitionStrategy");
+ if (options.partitionKey !== undefined)
+ this.configuration.set("partitionKey", options.partitionKey);
+ if (options.writePartition !== undefined)
+ this.configuration.set("writePartition", options.writePartition);
+ if (options.readPartitions !== undefined)
+ this.configuration.set("readPartitions", options.readPartitions);
+ if (options.includeMetaProperties !== undefined)
+ this.configuration.set("includeMetaProperties", options.includeMetaProperties);
+ }
+}
+
+class SubgraphStrategy extends TraversalStrategy {
+ /**
+ * @param {Object} [options]
+ * @param {GraphTraversal} [options.vertices] name of the property key to partition by
+ * @param {GraphTraversal} [options.edges] the value of the currently write partition
+ * @param {GraphTraversal} [options.vertexProperties] list of strings representing the partitions to include for reads
+ * @param {boolean} [options.checkAdjacentVertices] enables the strategy to apply the {@code vertices} filter to the adjacent vertices of an edge.
+ */
+ constructor(options) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SubgraphStrategy");
+ if (options.vertices !== undefined)
+ this.configuration.set("vertices", options.vertices);
+ if (options.edges !== undefined)
+ this.configuration.set("edges", options.edges);
+ if (options.vertexProperties !== undefined)
+ this.configuration.set("vertexProperties", options.vertexProperties);
+ if (options.checkAdjacentVertices !== undefined)
+ this.configuration.set("checkAdjacentVertices", options.checkAdjacentVertices);
+ }
+}
+
class VertexProgramStrategy extends TraversalStrategy {
- constructor(graphComputer, workers, persist, result, vertices, edges, configuration) {
- super();
+ constructor(options) {
+ super("org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.VertexProgramStrategy");
this.configuration = new Map();
- if (graphComputer !== undefined)
- this.configuration.set("graphComputer", graphComputer);
- if (workers !== undefined)
- this.configuration.set("workers", workers);
- if (persist !== undefined)
- this.configuration.set("persist", persist);
- if (result !== undefined)
- this.configuration.set("result", result);
- if (vertices !== undefined)
- this.configuration.set("vertices", vertices);
- if (edges !== undefined)
- this.configuration.set("edges", edges);
- if (configuration !== undefined)
- configuration.forEach(function(k,v) {
+ if (options.graphComputer !== undefined)
+ this.configuration.set("graphComputer", options.graphComputer);
+ if (options.workers !== undefined)
+ this.configuration.set("workers", options.workers);
+ if (options.persist !== undefined)
+ this.configuration.set("persist", options.persist);
+ if (options.result !== undefined)
+ this.configuration.set("result", options.result);
+ if (options.vertices !== undefined)
+ this.configuration.set("vertices", options.vertices);
+ if (options.edges !== undefined)
+ this.configuration.set("edges", options.edges);
+ if (options.configuration !== undefined)
+ options.configuration.forEach(function(k,v) {
this.configuration.set(k, v);
});
}
}
+class MatchAlgorithmStrategy extends TraversalStrategy {
+ /**
+ * @param matchAlgorithm
+ */
+ constructor(matchAlgorithm) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy");
+ if (graphComputer !== undefined)
+ this.configuration.set("matchAlgorithm", matchAlgorithm);
+ }
+}
+
+class AdjacentToIncidentStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy");
+ }
+}
+
+class FilterRankingStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.FilterRankingStrategy");
+ }
+}
+
+class IdentityRemovalStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IdentityRemovalStrategy");
+ }
+}
+
+class IncidentToAdjacentStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.IncidentToAdjacentStrategy");
+ }
+}
+
+class InlineFilterStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.InlineFilterStrategy");
+ }
+}
+
+class LazyBarrierStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy");
+ }
+}
+
+class MatchPredicateStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.MatchPredicateStrategy");
+ }
+}
+
+class OrderLimitStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.OrderLimitStrategy");
+ }
+}
+
+class PathProcessorStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathProcessorStrategy");
+ }
+}
+
+class PathRetractionStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.PathRetractionStrategy");
+ }
+}
+
+class CountStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy");
+ }
+}
+
+class RepeatUnrollStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.RepeatUnrollStrategy");
+ }
+}
+
+class GraphFilterStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.GraphFilterStrategy");
+ }
+}
+
+class EarlyLimitStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.EarlyLimitStrategy");
+ }
+}
+
+class LambdaRestrictionStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy");
+ }
+}
+
+class ReadOnlyStrategy extends TraversalStrategy {
+ constructor() {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy");
+ }
+}
+
+class EdgeLabelVerificationStrategy extends TraversalStrategy {
+ /**
+ * @param {boolean} logWarnings determines if warnings should be written to the logger when verification fails
+ * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
+ */
+ constructor(logWarnings = false, throwException=false) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy");
+ this.configuration.set("logWarnings", logWarnings);
+ this.configuration.set("throwException", throwException);
+ }
+}
+
+class ReservedKeysVerificationStrategy extends TraversalStrategy {
+ /**
+ * @param {boolean} logWarnings determines if warnings should be written to the logger when verification fails
+ * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
+ * @param {Array<String>} keys the list of reserved keys to verify
+ */
+ constructor(logWarnings = false, throwException=false, keys=["id", "label"]) {
+ super("org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy");
+ this.configuration.set("logWarnings", logWarnings);
+ this.configuration.set("throwException", throwException);
+ this.configuration.set("keys", keys);
+ }
+}
+
module.exports = {
TraversalStrategies: TraversalStrategies,
TraversalStrategy: TraversalStrategy,
- VertexProgramStrategy: VertexProgramStrategy
+ // decoration
+ ConnectiveStrategy: ConnectiveStrategy,
+ ElementIdStrategy: ElementIdStrategy,
+ HaltedTraverserStrategy: HaltedTraverserStrategy,
+ OptionsStrategy: OptionsStrategy,
+ PartitionStrategy: PartitionStrategy,
+ SubgraphStrategy: SubgraphStrategy,
+ VertexProgramStrategy: VertexProgramStrategy,
+ // finalization
+ MatchAlgorithmStrategy: MatchAlgorithmStrategy,
+ // optimization
+ AdjacentToIncidentStrategy: AdjacentToIncidentStrategy,
+ FilterRankingStrategy: FilterRankingStrategy,
+ IdentityRemovalStrategy: IdentityRemovalStrategy,
+ IncidentToAdjacentStrategy: IncidentToAdjacentStrategy,
+ InlineFilterStrategy: InlineFilterStrategy,
+ LazyBarrierStrategy: LazyBarrierStrategy,
+ MatchPredicateStrategy: MatchPredicateStrategy,
+ OrderLimitStrategy: OrderLimitStrategy,
+ PathProcessorStrategy: PathProcessorStrategy,
+ PathRetractionStrategy: PathRetractionStrategy,
+ CountStrategy: CountStrategy,
+ RepeatUnrollStrategy: RepeatUnrollStrategy,
+ GraphFilterStrategy: GraphFilterStrategy,
+ EarlyLimitStrategy: EarlyLimitStrategy,
+ // verification
+ EdgeLabelVerificationStrategy: EdgeLabelVerificationStrategy,
+ LambdaRestrictionStrategy: LambdaRestrictionStrategy,
+ ReadOnlyStrategy: ReadOnlyStrategy,
+ ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy
};
\ No newline at end of file
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/integration/traversal-test.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/integration/traversal-test.js
index 453423a..cfa99dd 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/integration/traversal-test.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/integration/traversal-test.js
@@ -23,10 +23,12 @@
'use strict';
const assert = require('assert');
+const expect = require('chai').expect;
const { Vertex } = require('../../lib/structure/graph');
const { traversal } = require('../../lib/process/anonymous-traversal');
-const { GraphTraversalSource } = require('../../lib/process/graph-traversal');
-const { GraphTraversal, statics } = require('../../lib/process/graph-traversal');
+const { GraphTraversalSource, GraphTraversal, statics } = require('../../lib/process/graph-traversal');
+const { SubgraphStrategy, ReadOnlyStrategy,
+ ReservedKeysVerificationStrategy, EdgeLabelVerificationStrategy } = require('../../lib/process/traversal-strategy');
const Bytecode = require('../../lib/process/bytecode');
const helper = require('../helper');
const __ = statics;
@@ -134,7 +136,7 @@ describe('Traversal', function () {
});
describe("more complex traversals", function() {
it('should return paths of value maps', function() {
- var g = traversal().withRemote(connection);
+ const g = traversal().withRemote(connection);
return g.V(1).out().in_().limit(1).path().by(__.valueMap('name')).toList().then(function (list) {
assert.ok(list);
assert.strictEqual(list.length, 1);
@@ -144,4 +146,42 @@ describe('Traversal', function () {
});
});
});
+ describe("should allow TraversalStrategy definition", function() {
+ it('should allow SubgraphStrategy', function() {
+ const g = traversal().withRemote(connection).withStrategies(
+ new SubgraphStrategy({vertices:__.hasLabel("person"), edges:__.hasLabel("created")}));
+ g.V().count().next().then(function (item1) {
+ assert.ok(item1);
+ assert.strictEqual(item1.value, 4);
+ });
+ g.E().count().next().then(function (item1) {
+ assert.ok(item1);
+ assert.strictEqual(item1.value, 0);
+ });
+ g.V().label().dedup().count().next().then(function (item1) {
+ assert.ok(item1);
+ assert.strictEqual(item1.value, 1);
+ });
+ g.V().label().dedup().next().then(function (item1) {
+ assert.ok(item1);
+ assert.strictEqual(item1.value, "person");
+ });
+ });
+ it('should allow ReadOnlyStrategy', function() {
+ const g = traversal().withRemote(connection).withStrategies(new ReadOnlyStrategy());
+ return g.addV().iterate().then(() => assert.fail("should have tanked"), (err) => assert.ok(err));
+ });
+ it('should allow ReservedKeysVerificationStrategy', function() {
+ const g = traversal().withRemote(connection).withStrategies(new ReservedKeysVerificationStrategy(false, true));
+ return g.addV().property("id", "please-don't-use-id").iterate().then(() => assert.fail("should have tanked"), (err) => assert.ok(err));
+ });
+ it('should allow EdgeLabelVerificationStrategy', function() {
+ const g = traversal().withRemote(connection).withStrategies(new EdgeLabelVerificationStrategy(false, true));
+ g.V().outE("created", "knows").count().next().then(function (item1) {
+ assert.ok(item1);
+ assert.strictEqual(item1.value, 6);
+ });
+ return g.V().out().iterate().then(() => assert.fail("should have tanked"), (err) => assert.ok(err));
+ });
+ });
});
\ No newline at end of file
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/translator-test.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/translator-test.js
index 91c903e..a714ef5 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/translator-test.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/test/unit/translator-test.js
@@ -20,11 +20,8 @@
'use strict';
const assert = require('assert');
-const expect = require('chai').expect;
const graph = require('../../lib/structure/graph');
const t = require('../../lib/process/traversal');
-const TraversalStrategies = require('../../lib/process/traversal-strategy').TraversalStrategies;
-const Bytecode = require('../../lib/process/bytecode');
const Translator = require('../../lib/process/translator');
const graphTraversalModule = require('../../lib/process/graph-traversal');
const __ = graphTraversalModule.statics;