标签: gremlin

已经有一些关于这个主题的话题了..特别是这个

但是除了批处理之外，还有什么推荐的解决方案可以删除大图吗？我尝试增加超时时间但不起作用

下面是例子..

gremlin> gV().count()

==>5230885

gremlin> gV().drop().iterate()

{“requestId”：“77c64369-45fa-462f-91d7-5712e3308497”，“detailedMessage”：“评估[RequestMessage{期间脚本内发生超时，requestId = 77c64369-45fa-462f-91d7-5712e3308497，op =' eval',processor='',args={gremlin=gV().drop().iterate(),bindings={},batchSize=64}}] - 考虑增加超时","code":"TimeLimitExceededException"输入 ':help' 或 ':h' 获取帮助。显示堆栈跟踪？[yN]N

gremlin> gE().count()

==>83330550

gremlin> ：远程配置超时无

==>远程超时已禁用

gremlin> gE().drop().iterate()

{“requestId”：“d418fa03-72ce-4154-86d8-42225e4b9eca”，“detailedMessage”：“评估[RequestMessage{期间脚本内发生超时，requestId = d418fa03-72ce-4154-86d8-42225e4b9eca，op =' eval',processor='',args={gremlin=gE().drop().iterate(),bindings={},batchSize=64}}] - 考虑增加超时","code":"TimeLimitExceededException"输入 ':help' 或 ':h' 获取帮助。显示堆栈跟踪？[yN]N

假设我想从数据库中获取一些顶点：

g.V(1, 2, 3)

然后我有另一组顶点：

g.V(4, 5, 6)

想象一下，这不仅仅是g.V()，而是一些更复杂的遍历来获取我的顶点。但遍历必须从 开始V()，因为我想从所有节点中进行选择。

我们还假设我想多次这样做。所以我可能想合并 7 个不同的结果集。每一种方法都可以采用完全不同的方式来获得结果。

现在我想将这两个结果合并到一个结果集中。我的第一个想法是：

g.V(1, 2, 3).fold().as('x').V(4, 5, 6).fold().as('x').select(all, 'x').unfold()

但这行不通。第二次调用fold将清除我的“局部变量”，因为这是一个障碍步骤。

我目前的尝试是这样的：

g.V(1, 2, 3).fold().union(identity(), V(4, 5, 6).fold()).unfold()

这可行，但看起来有点太复杂了。如果我想重复 7 次，这将是一个非常复杂的查询。

有没有更好的方法来完成两个不同查询结果的简单合并？

我正在尝试编写一个满足响应对象中两个要求的查询：

1. 必须包括顶点的所有属性，而不在查询中指定单个字段。

2. 必须在对象的同一级别上展平结果。

作为单独的查询，我可以这样做：

1.valueMap查询

g.V(1)
.valueMap().by(unfold()).fold()

回复：

g.V(1)
.valueMap().by(unfold()).fold()

2.project查询

g.V(1)
.project("projectedProperty")
.by(out("X").valueMap().by(unfold()).fold())

回复：

{
  "property1": "value1",
  "property2": "value2"
}

组合查询

我尝试使用联合来组合这些结果：

g.V(1)
.union(
  valueMap().by(unfold()).fold(), // Query 1
  project("projectedField").by(out("X").valueMap().by(unfold()).fold()) // Query 2
).fold()

回复：

g.V(1)
.project("projectedProperty")
.by(out("X").valueMap().by(unfold()).fold())

这种联合方法依赖于我在最后折叠，这反过来又不能正确合并/展平两张地图。预期响应是：

{
  "projectedProperty": "value",
}

有没有更好的方法来完成合并/展平响应对象中的两个地图的任务？

非常感谢您提前的帮助

我尝试按照https://docs.aws.amazon.com/neptune/latest/userguide/get-started.html中的说明设置我的 AWS Neptune 环境。设置似乎很好，我可以使用 Neptune Notebook 安装来检查状态。状态消息为：

{
  "status": "healthy",
  "startTime": "Tue May 12 04:24:52 UTC 2020",
  "dbEngineVersion": "1.0.2.2.R2",
  "role": "writer",
  "gremlin": {
    "version": "tinkerpop-3.4.3"
  },
  "sparql": {
    "version": "sparql-1.1"
  },
  "labMode": {
    "ObjectIndex": "disabled",
    "ReadWriteConflictDetection": "enabled"
  }
}

但是，我无法通过 EC2 客户端实例中的 Gremlin 控制台连接到它，我收到 403 禁止错误，如下所示：

         \,,,/
         (o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin> :remote connect tinkerpop.server conf/neptune-remote.yaml
WARN  org.apache.tinkerpop.gremlin.driver.Cluster  - Using deprecated SSL trustCertChainFile support
ERROR org.apache.tinkerpop.gremlin.driver.Handler$GremlinResponseHandler  - Could not …

我目前正在使用 TinkerPop java API 进行图形遍历。目前，我必须创建相同遍历的重复副本来计算计数。

Long allUsersCount = gt.V().hasLabel("user").has("name", "John").count().next();
List<Vertex> users = gt.V().hasLabel("user").has("name", "John").toList();

当我尝试重用返回的遍历来gt.V().hasLabel("user").has("name", "John").count()获取列表时，它导致了错误

java.lang.IllegalStateException：遍历策略已完成，无法再调制遍历

我只是想知道是否有任何方法可以避免这种重复，因为两种情况的遍历都是相同的，gt.V().hasLabel("user").has("name", "John")只是终止操作不同。

有没有办法存储中间的计数（在java变量内）并继续遍历以获取用户列表。

上下文：

我确实有一个大约有 2000 个顶点和 6000 条边的图，随着时间的推移，这可能会增长到 10000 个顶点和 100000 条边。目前我正在使用以下遍历查询更新新顶点：

向上插入顶点和边

queryVertex = "g.V().has(label, name, foo).fold().coalesce(
               unfold(), addV(label).property(name, foo).property(model, 2)
               ).property(model, 2)"

这里的目的是寻找名为 foo 的顶点，如果找到则更新其model属性，否则创建一个新顶点并设置该model属性。这发出两次：一次是针对源顶点，一次是针对目标顶点。
创建两个相关顶点后，将发出另一个查询以创建它们之间的边：

queryEdge = "g.V('id_of_source_vertex').coalesce(
             outE(edge_label).filter(inV().hasId('id_of_target_vertex')), 
             addE(edge_label).to(V('id_of_target_vertex'))
             ).property(model, 2)"

在这里，如果两个顶点之间存在model边，则更新边上的属性，否则会在它们之间创建边。

执行此操作的伪代码如下：

for each edge in the list of new edges:
   //upsert source and target vertices:  
   execute queryVertex for edge.source
   execute queryVertex for edge.target
   // upsert edge: 
   execute queryEdge

这行得通，但效率极低；例如，对于上述图形大小，它需要几分钟才能完成，并且通过一些应用内并发，它只将时间减少了几分钟。当然，对于如此小的图尺寸，必须有一种更有效的方法来做到这一点。

问题
* 如何使这些 upsert 更快？

特别是遵循此处的教程：https : //kelvinlawrence.net/book/Gremlin-Graph-Guide.html#walk (3.3.2)

我不明白这个说法 outE().inV()

取自 g.V().has('airport','code','LCY').outE().inV().path()

解释是：

“从 LCY 顶点开始，找到所有输出边，并找到位于这些边另一端的所有顶点”。inV 步骤为我们提供了出边另一端的顶点。

然后在3.3。开始走图， 我们在表 1 中找到以下定义：

outV 输出顶点。

inV 传入顶点。

如何在地球上 传入顶点=顶点在传出边缘的另一端

如果有的话，如果 OutV 而不是 InV ，我会认为出边另一端的顶点。

因此，有人可以澄清 inV 和 outV 的含义吗？

我们是说，如果我有一个有向边 A -> B，则该边的传入顶点是 B，而该边的传出顶点是 A 吗？不确定，但如果是这样，该术语的基础如何，听起来与直觉相反，因为在使用 Vertex 时似乎相反。

我是小精灵的新手。我试图根据某些条件获得一些随机顶点。但是，如果我使用带有一些数学计算的示例方法，则它不起作用。但是如果我给出整数值，它就可以正常工作。

以下查询工作正常：

g.V().hasLabel('Person').sample(1)

以下查询不起作用：

g.V().hasLabel('Person').sample(math('4/2'))

实际上，根据人数，我应该在样本方法中执行一些数学计算。提前致谢

从 java 客户端检索边时，JanusGraph v0.5.3 服务器日志中显示以下错误

12277786 [gremlin-server-exec-7] WARN  org.apache.tinkerpop.gremlin.server.op.AbstractEvalOpProcessor  - The result [[e[ofncw-iyo-4avp-374][24576-hasTag->4144]]] in the request 098dc551-6558-497a-a066-b293edd29833 could not be serialized and returned.
org.apache.tinkerpop.gremlin.driver.ser.SerializationException: java.io.IOException: Serializer for type org.janusgraph.graphdb.relations.RelationIdentifier not found
    at org.apache.tinkerpop.gremlin.driver.ser.binary.ResponseMessageSerializer.writeValue(ResponseMessageSerializer.java:86)
    at org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1.serializeResponseAsBinary(GraphBinaryMessageSerializerV1.java:143)
    at org.apache.tinkerpop.gremlin.server.op.AbstractOpProcessor.makeFrame(AbstractOpProcessor.java:335)
    at org.apache.tinkerpop.gremlin.server.op.traversal.TraversalOpProcessor.handleIterator(TraversalOpProcessor.java:580)
    at org.apache.tinkerpop.gremlin.server.op.traversal.TraversalOpProcessor.lambda$iterateBytecodeTraversal$4(TraversalOpProcessor.java:411)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)
Caused by: java.io.IOException: Serializer for type org.janusgraph.graphdb.relations.RelationIdentifier not found
    at org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializerRegistry.validateInstance(TypeSerializerRegistry.java:392)
    at org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializerRegistry.getSerializer(TypeSerializerRegistry.java:361)
    at org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter.write(GraphBinaryWriter.java:90)
    at org.apache.tinkerpop.gremlin.structure.io.binary.types.EdgeSerializer.writeValue(EdgeSerializer.java:63)
    at org.apache.tinkerpop.gremlin.structure.io.binary.types.EdgeSerializer.writeValue(EdgeSerializer.java:34)
    at org.apache.tinkerpop.gremlin.structure.io.binary.types.SimpleTypeSerializer.writeValue(SimpleTypeSerializer.java:91)
    at org.apache.tinkerpop.gremlin.structure.io.binary.types.SimpleTypeSerializer.write(SimpleTypeSerializer.java:73)
    at org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter.write(GraphBinaryWriter.java:112)
    at org.apache.tinkerpop.gremlin.structure.io.binary.types.TraverserSerializer.writeValue(TraverserSerializer.java:49) …

我已阅读有关匿名遍历的文档。我知道它们可以开始使用__，并且可以在步进调制器内使用。虽然我从概念上不理解它。为什么我们不能使用从步骤调制器内的图遍历源生成的正常遍历？例如，在下面的 gremlin 代码中创建一条边

        this.g
            .V(fromId) // get vertex of id given for the source
            .as("fromVertex") // label as fromVertex to be accessed later
            .V(toId) // get  vertex of id given for destination
            .coalesce( // evaluates the provided traversals in order and returns the first traversal that emits at least one element
                inE(label) // check incoming edge of label given
                    .where( // conditional check to check if edge exists
                        outV() // get destination vertex of the edge to check …