perf: more optimizations on using GAV from in Gremlin and SQL

lvca · lvca · commit 1d73c9de9323 · 2026-03-23T16:40:25.000-04:00
diff --git a/engine/src/main/java/com/arcadedb/function/sql/graph/SQLFunctionAstar.java b/engine/src/main/java/com/arcadedb/function/sql/graph/SQLFunctionAstar.java
@@ -24,6 +24,8 @@
 import com.arcadedb.database.RID;
 import com.arcadedb.database.Record;
 import com.arcadedb.graph.Edge;
+import com.arcadedb.graph.GraphTraversalProvider;
+import com.arcadedb.graph.GraphTraversalProviderRegistry;
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.sql.executor.CommandContext;
 import com.arcadedb.query.sql.executor.MultiValue;
@@ -164,24 +166,24 @@ private LinkedList<RID> internalExecute(final CommandContext ctx, final Database
       }
 
       closedSet.add(current);
-      for (final Edge neighborEdge : getNeighborEdges(current)) {
 
-        final Vertex neighbor = getNeighbor(current, neighborEdge, graph);
+      // Try CSR + edge property columns first for O(1) neighbor + weight access
+      final Map<Vertex, Double> neighborWeights = getNeighborWeightsCSR(current, ctx);
+      for (final Map.Entry<Vertex, Double> entry : neighborWeights.entrySet()) {
+        final Vertex neighbor = entry.getKey();
         // Ignore the neighbor which is already evaluated.
-        if (closedSet.contains(neighbor)) {
+        if (closedSet.contains(neighbor))
           continue;
-        }
         // The distance from start to a neighbor
-        final double tentative_gScore = gScore.get(current) + getDistance(neighborEdge);
+        final double tentative_gScore = gScore.get(current) + entry.getValue();
         final boolean contains = open.contains(neighbor);
 
         if (!contains || tentative_gScore < gScore.get(neighbor)) {
           gScore.put(neighbor, tentative_gScore);
           fScore.put(neighbor, tentative_gScore + getHeuristicCost(neighbor, current, goal, ctx));
 
-          if (contains) {
+          if (contains)
             open.remove(neighbor);
-          }
           open.offer(neighbor);
           cameFrom.put(neighbor, current);
         }
@@ -218,14 +220,60 @@ protected Set<Edge> getNeighborEdges(final Vertex node) {
     final Set<Edge> neighbors = new HashSet<Edge>();
     if (node != null) {
       for (final Edge v : node.getEdges(paramDirection, paramEdgeTypeNames)) {
-        final Edge ov = v;
-        if (ov != null)
-          neighbors.add(ov);
+        if (v != null)
+          neighbors.add(v);
       }
     }
     return neighbors;
   }
 
+  /**
+   * Returns neighbor vertices with their edge weights using CSR + edge property columns when available.
+   * Falls back to OLTP edge traversal when GAV doesn't have edge properties or doesn't cover the node.
+   */
+  protected Map<Vertex, Double> getNeighborWeightsCSR(final Vertex node, final CommandContext ctx) {
+    final Map<Vertex, Double> result = new HashMap<>();
+    if (node == null)
+      return result;
+
+    final GraphTraversalProvider provider = GraphTraversalProviderRegistry.findProvider(
+        ctx.getDatabase(), paramEdgeTypeNames);
+    if (provider != null && provider.hasEdgeProperties()) {
+      final int nodeId = provider.getNodeId(node.getIdentity());
+      if (nodeId >= 0) {
+        final int[] neighborIds = paramEdgeTypeNames != null && paramEdgeTypeNames.length > 0
+            ? provider.getNeighborIds(nodeId, paramDirection, paramEdgeTypeNames)
+            : provider.getNeighborIds(nodeId, paramDirection);
+        final String edgeType = paramEdgeTypeNames != null && paramEdgeTypeNames.length > 0 ? paramEdgeTypeNames[0] : null;
+        for (int i = 0; i < neighborIds.length; i++) {
+          final RID neighborRid = provider.getRID(neighborIds[i]);
+          if (neighborRid != null) {
+            double weight = MIN;
+            if (edgeType != null) {
+              final Object wObj = provider.getEdgeProperty(nodeId, i, paramDirection, edgeType, paramWeightFieldName);
+              if (wObj instanceof Number num)
+                weight = num.doubleValue();
+            }
+            try {
+              result.put(neighborRid.asVertex(), weight);
+            } catch (final Exception e) {
+              // deleted vertex — skip
+            }
+          }
+        }
+        return result;
+      }
+    }
+
+    // OLTP fallback
+    for (final Edge edge : node.getEdges(paramDirection, paramEdgeTypeNames)) {
+      final Vertex neighbor = getNeighbor(node, edge, ctx.getDatabase());
+      if (neighbor != null)
+        result.put(neighbor, getDistance(edge));
+    }
+    return result;
+  }
+
   private void bindAdditionalParams(final Object additionalParams, final SQLFunctionAstar context) {
     if (additionalParams == null) {
       return;
diff --git a/engine/src/main/java/com/arcadedb/function/sql/graph/SQLFunctionBellmanFord.java b/engine/src/main/java/com/arcadedb/function/sql/graph/SQLFunctionBellmanFord.java
@@ -23,6 +23,8 @@
 import com.arcadedb.database.Record;
 import com.arcadedb.function.sql.math.SQLFunctionMathAbstract;
 import com.arcadedb.graph.Edge;
+import com.arcadedb.graph.GraphTraversalProvider;
+import com.arcadedb.graph.GraphTraversalProviderRegistry;
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.sql.executor.CommandContext;
 import com.arcadedb.schema.DocumentType;
@@ -95,13 +97,49 @@ public Object execute(final Object self, final Identifiable currentRecord, final
     Arrays.fill(prev, -1);
     dist[startIdx] = 0.0;
 
-    // Collect all edges based on direction
+    // Collect all edges based on direction — use CSR + edge properties when available
     final List<int[]> edgeList = new ArrayList<>();
     final List<Double> edgeWeights = new ArrayList<>();
+    final Vertex.DIRECTION dir = parseDirection(direction);
+
+    final GraphTraversalProvider provider = GraphTraversalProviderRegistry.findProvider(db);
+    final boolean useCSR = provider != null && provider.hasEdgeProperties();
 
     for (int i = 0; i < n; i++) {
       final Vertex v = vertices.get(i);
-      final Vertex.DIRECTION dir = parseDirection(direction);
+
+      if (useCSR) {
+        final int nodeId = provider.getNodeId(v.getIdentity());
+        if (nodeId >= 0) {
+          final int[] neighborIds = provider.getNeighborIds(nodeId, dir);
+          for (int ni = 0; ni < neighborIds.length; ni++) {
+            final var neighborRid = provider.getRID(neighborIds[ni]);
+            if (neighborRid == null)
+              continue;
+            // Find vertex index — look up by RID in the map
+            final Vertex neighborVertex;
+            try {
+              neighborVertex = neighborRid.asVertex();
+            } catch (final Exception e) {
+              continue;
+            }
+            final Integer j = vertexIndex.get(neighborVertex);
+            if (j == null)
+              continue;
+            double w = 1.0;
+            if (weightProperty != null && !weightProperty.isEmpty()) {
+              final Object wObj = provider.getEdgeProperty(nodeId, ni, dir, null, weightProperty);
+              if (wObj instanceof Number num)
+                w = num.doubleValue();
+            }
+            edgeList.add(new int[] { i, j });
+            edgeWeights.add(w);
+          }
+          continue;
+        }
+      }
+
+      // OLTP fallback
       for (final Edge edge : v.getEdges(dir)) {
         final Vertex neighbor;
         if (dir == Vertex.DIRECTION.OUT)
diff --git a/engine/src/main/java/com/arcadedb/graph/CSRVertexIterable.java b/engine/src/main/java/com/arcadedb/graph/CSRVertexIterable.java
@@ -26,6 +26,11 @@
 /**
  * Lazy iterable that converts CSR dense node IDs to Vertex objects on demand.
  * Used by SQL graph functions (out/in/both) when a GAV provider is available.
+ * <p>
+ * Provides an O(1) {@link #size()} method that returns the neighbor count directly
+ * from the CSR array length, avoiding the need to iterate all elements.
+ *
+ * @author Luca Garulli (l.garulli@arcadedata.com)
  */
 public class CSRVertexIterable implements Iterable<Vertex> {
   private final GraphTraversalProvider provider;
@@ -36,6 +41,14 @@ public CSRVertexIterable(final GraphTraversalProvider provider, final int[] neig
     this.neighborIds = neighborIds;
   }
 
+  /**
+   * Returns the neighbor count in O(1) directly from the CSR array length.
+   * This avoids materializing all vertices just to count them.
+   */
+  public int size() {
+    return neighborIds.length;
+  }
+
   @Override
   public Iterator<Vertex> iterator() {
     return new Iterator<>() {
diff --git a/engine/src/main/java/com/arcadedb/query/sql/method/collection/SQLMethodSize.java b/engine/src/main/java/com/arcadedb/query/sql/method/collection/SQLMethodSize.java
@@ -20,6 +20,7 @@
 
 import com.arcadedb.database.Identifiable;
 import com.arcadedb.database.Record;
+import com.arcadedb.graph.CSRVertexIterable;
 import com.arcadedb.query.sql.executor.CommandContext;
 import com.arcadedb.query.sql.executor.MultiValue;
 import com.arcadedb.query.sql.executor.Result;
@@ -44,6 +45,7 @@ public Object execute(final Object value, final Identifiable currentRecord, fina
     final int size;
     if (value != null) {
       switch (value) {
+      case CSRVertexIterable csr -> size = csr.size(); // O(1) via CSR array length
       case Result result -> size = result.getRecord().isPresent() ? result.getRecord().get().size() : -1;
       case Identifiable rid -> {
         final Record record = rid.getRecord(true);
diff --git a/gremlin/src/main/java/com/arcadedb/gremlin/ArcadeEdgeCountFilterStep.java b/gremlin/src/main/java/com/arcadedb/gremlin/ArcadeEdgeCountFilterStep.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.gremlin;
+
+import com.arcadedb.database.RID;
+import com.arcadedb.graph.GraphTraversalProvider;
+import com.arcadedb.graph.Vertex;
+import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
+import org.apache.tinkerpop.gremlin.process.traversal.Traverser;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.FilterStep;
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
+
+import java.util.function.Predicate;
+
+/**
+ * GAV-accelerated filter step that replaces the pattern
+ * {@code where(outE('X').count().is(predicate))} with O(1) degree lookup via
+ * {@link GraphTraversalProvider#countEdges}.
+ * <p>
+ * Instead of materializing all edges to count them, this step calls
+ * {@code provider.countEdges(nodeId, direction, edgeLabels)} which is a simple
+ * offset subtraction on the CSR arrays.
+ *
+ * @author Luca Garulli (l.garulli@arcadedata.com)
+ */
+class ArcadeEdgeCountFilterStep extends FilterStep<org.apache.tinkerpop.gremlin.structure.Vertex> {
+  private final GraphTraversalProvider provider;
+  private final Vertex.DIRECTION       direction;
+  private final String[]               edgeLabels;
+  private final Predicate<Long>        predicate;
+
+  ArcadeEdgeCountFilterStep(final Traversal.Admin<?, ?> traversal, final GraphTraversalProvider provider,
+      final Direction direction, final String[] edgeLabels, final Predicate<Long> predicate) {
+    super(traversal);
+    this.provider = provider;
+    this.direction = ArcadeGraph.mapDirection(direction);
+    this.edgeLabels = edgeLabels;
+    this.predicate = predicate;
+  }
+
+  @Override
+  protected boolean filter(final Traverser.Admin<org.apache.tinkerpop.gremlin.structure.Vertex> traverser) {
+    final org.apache.tinkerpop.gremlin.structure.Vertex gremlinVertex = traverser.get();
+
+    final RID rid;
+    if (gremlinVertex instanceof ArcadeVertex arcadeVertex)
+      rid = arcadeVertex.getBaseElement().getIdentity();
+    else
+      rid = null;
+
+    if (rid != null) {
+      final int nodeId = provider.getNodeId(rid);
+      if (nodeId >= 0) {
+        final long count = edgeLabels.length == 0
+            ? provider.countEdges(nodeId, direction)
+            : provider.countEdges(nodeId, direction, edgeLabels);
+        return predicate.test(count);
+      }
+    }
+
+    // OLTP fallback: iterate edges and count
+    long count = 0;
+    final var edgeIter = gremlinVertex.edges(
+        switch (direction) {
+          case OUT -> Direction.OUT;
+          case IN -> Direction.IN;
+          case BOTH -> Direction.BOTH;
+        }, edgeLabels);
+    while (edgeIter.hasNext()) {
+      edgeIter.next();
+      count++;
+    }
+    return predicate.test(count);
+  }
+
+  @Override
+  public String toString() {
+    return StringFactory.stepString(this, direction, String.join(",", edgeLabels), predicate, "GAV");
+  }
+}
diff --git a/gremlin/src/main/java/com/arcadedb/gremlin/ArcadeTraversalStrategy.java b/gremlin/src/main/java/com/arcadedb/gremlin/ArcadeTraversalStrategy.java
