fix: [sql] issues with MOVE VERTEX command

Fixed issue ArcadeData#4461

The native ANTLR SQL parser's MOVE VERTEX support was incomplete on multiple fronts. I reproduced every reported case, fixed the root causes, and added regression tests.

Author: lvca

engine/src/main/antlr4/com/arcadedb/query/sql/grammar/SQLParser.g4

@@ -421,13 +421,16 @@ deleteFunctionStatement
 
 /**
  * MOVE VERTEX statement
- * MOVE VERTEX source TO target [SET ...] [MERGE ...]
- * Supports: MOVE VERTEX expr TO type:TypeName or TO TypeName or TO BUCKET:name
+ * MOVE VERTEX source TO target [SET ...|REMOVE ...|MERGE ...|CONTENT ...] [BATCH n]
+ * Supports: MOVE VERTEX expr TO type:TypeName or TO TypeName or TO bucket:name or TO bucket:id
  */
 moveVertexStatement
-    : MOVE VERTEX expression TO (TYPE COLON identifier | BUCKET COLON identifier | identifier)
-      (SET updateItem (COMMA updateItem)*)?
-      (MERGE expression)?
+    : MOVE VERTEX expression TO ( TYPE COLON identifier
+                               | BUCKET COLON identifier
+                               | BUCKET_IDENTIFIER
+                               | BUCKET_NUMBER_IDENTIFIER
+                               | identifier )
+      updateOperation?
       (BATCH expression)?
     ;
 

engine/src/main/java/com/arcadedb/query/sql/antlr/SQLASTBuilder.java

@@ -4730,11 +4730,10 @@ else if (baseExpr.inputParam != null)
     return stmt;
   }
 
-  // TODO: Complete MOVE VERTEX visitor implementation - temporarily disabled
-  // /**
-  //  * Visit MOVE VERTEX statement.
-  //  * Supports: MOVE VERTEX expr TO type:TypeName or TO TypeName or TO bucket:name
-  //  */
+  /**
+   * Visit MOVE VERTEX statement.
+   * Supports: MOVE VERTEX expr TO type:TypeName | TO bucket:name | TO bucket:id [SET|REMOVE|MERGE|CONTENT ...] [BATCH n]
+   */
   @Override
   public MoveVertexStatement visitMoveVertexStmt(final SQLParser.MoveVertexStmtContext ctx) {
     final MoveVertexStatement stmt = new MoveVertexStatement(-1);
@@ -4769,30 +4768,31 @@ public MoveVertexStatement visitMoveVertexStmt(final SQLParser.MoveVertexStmtCon
     }
     stmt.source = fromItem;
 
-    // Target: TYPE:identifier or BUCKET:identifier or identifier (bucket name)
+    // Target: TYPE:identifier, BUCKET:name, bucket:name (single token), bucket:id (single token) or bare identifier (bucket name)
     if (moveCtx.TYPE() != null) {
       // TO TYPE:typename
       stmt.targetType = (Identifier) visit(moveCtx.identifier());
+    } else if (moveCtx.BUCKET_IDENTIFIER() != null) {
+      // TO bucket:name (lexed as a single BUCKET_IDENTIFIER token)
+      final String text = moveCtx.BUCKET_IDENTIFIER().getText();
+      stmt.targetBucket = new Bucket(text.substring("bucket:".length()));
+    } else if (moveCtx.BUCKET_NUMBER_IDENTIFIER() != null) {
+      // TO bucket:123 (lexed as a single BUCKET_NUMBER_IDENTIFIER token)
+      final String text = moveCtx.BUCKET_NUMBER_IDENTIFIER().getText();
+      stmt.targetBucket = new Bucket(Integer.parseInt(text.substring("bucket:".length())));
     } else if (moveCtx.BUCKET() != null) {
-      // TO BUCKET:bucketname
+      // TO BUCKET : bucketname (separated tokens, e.g. with spaces around the colon)
       final Identifier bucketId = (Identifier) visit(moveCtx.identifier());
       stmt.targetBucket = new Bucket(bucketId.getStringValue());
     } else {
-      // TO bucketname (without BUCKET: prefix)
+      // TO bucketname (without bucket: prefix)
       final Identifier bucketId = (Identifier) visit(moveCtx.identifier());
       stmt.targetBucket = new Bucket(bucketId.getStringValue());
     }
 
-    // SET clause (updateItems)
-    if (moveCtx.SET() != null) {
-      final UpdateOperations updateOps = new UpdateOperations(-1);
-      updateOps.type = UpdateOperations.TYPE_SET;
-      for (final SQLParser.UpdateItemContext itemCtx : moveCtx.updateItem()) {
-        final UpdateItem item = (UpdateItem) visit(itemCtx);
-        updateOps.updateItems.add(item);
-      }
-      stmt.updateOperations = updateOps;
-    }
+    // Update operations: SET, ADD, PUT, REMOVE, INCREMENT, MERGE, CONTENT
+    if (moveCtx.updateOperation() != null)
+      stmt.updateOperations = (UpdateOperations) visit(moveCtx.updateOperation());
 
     // BATCH clause
     if (moveCtx.BATCH() != null) {

engine/src/main/java/com/arcadedb/query/sql/executor/MoveVertexStep.java

@@ -18,6 +18,7 @@
  */
 package com.arcadedb.query.sql.executor;
 
+import com.arcadedb.database.RID;
 import com.arcadedb.exception.TimeoutException;
 import com.arcadedb.graph.Vertex;
 import com.arcadedb.query.sql.parser.Bucket;
@@ -44,17 +45,22 @@ public MoveVertexStep(final Identifier targetType, final Bucket targetBucket, fi
   @Override
   public ResultSet syncPull(final CommandContext ctx, final int records) throws TimeoutException {
     final ResultSet prevResult = getPrev().syncPull(ctx, records);
+
+    // The moved vertices are re-created under the target type/bucket with a brand-new RID. Replace each input result with an
+    // updatable result wrapping the new record so that any following SET/REMOVE/MERGE/CONTENT operations and the final save act
+    // on the moved vertex, and so the new RID is returned to the caller.
+    final InternalResultSet result = new InternalResultSet();
     while (prevResult.hasNext()) {
-      final Result result = prevResult.next();
-      final Vertex v = result.getVertex().get();
+      final Result item = prevResult.next();
+      final Vertex v = item.getVertex().orElse(null);
       if (v != null) {
-        if (targetBucket != null)
-          v.moveToBucket(targetBucket);
-        else
-          v.moveToType(targetType);
-      }
+        final RID newIdentity = targetBucket != null ? v.moveToBucket(targetBucket) : v.moveToType(targetType);
+        final Vertex moved = ctx.getDatabase().lookupByRID(newIdentity, true).asVertex();
+        result.add(new UpdatableResult(moved.modify()));
+      } else
+        result.add(item);
     }
-    return prevResult;
+    return result;
   }
 
   @Override

engine/src/test/java/com/arcadedb/query/sql/executor/MoveVertexStatementExecutionTest.java

@@ -232,4 +232,99 @@ void moveVertexByRid() {
     assertThat(rs.hasNext()).isFalse();
     rs.close();
   }
+
+  /**
+   * Regression test for issue #4461: MOVE VERTEX must return the new RID of the moved (re-created) vertex,
+   * for both a literal RID source and a SELECT subquery source.
+   */
+  @Test
+  void moveVertexReturnsNewRid() {
+    final String typeA = "testMoveRetA";
+    final String typeB = "testMoveRetB";
+    database.getSchema().createVertexType(typeA);
+    database.getSchema().createVertexType(typeB);
+    database.setAutoTransaction(true);
+
+    final String rid1 = database.command("sql", "create vertex " + typeA).next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql", "MOVE VERTEX " + rid1 + " TO TYPE:" + typeB)) {
+      assertThat(rs.hasNext()).isTrue();
+      final Result moved = rs.next();
+      assertThat(moved.getIdentity()).isPresent();
+      assertThat(moved.getElement().get().getTypeName()).isEqualTo(typeB);
+      assertThat(rs.hasNext()).isFalse();
+    }
+
+    final String rid2 = database.command("sql", "create vertex " + typeA).next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql", "MOVE VERTEX (SELECT FROM " + rid2 + ") TO TYPE:" + typeB)) {
+      assertThat(rs.hasNext()).isTrue();
+      final Result moved = rs.next();
+      assertThat(moved.getIdentity()).isPresent();
+      // the moved record is a brand-new record, not the source RID
+      assertThat(moved.getIdentity().get().toString()).isNotEqualTo(rid2);
+      assertThat(moved.getElement().get().getTypeName()).isEqualTo(typeB);
+      assertThat(rs.hasNext()).isFalse();
+    }
+  }
+
+  /**
+   * Regression test for issue #4461: MOVE VERTEX ... TO bucket:name must parse and move the vertex to the target bucket.
+   */
+  @Test
+  void moveVertexToBucket() {
+    final String typeA = "testMoveBucketA";
+    database.getSchema().createVertexType(typeA).addBucket(database.getSchema().createBucket("testMoveBucket_extra"));
+    database.setAutoTransaction(true);
+
+    final String rid = database.command("sql", "create vertex " + typeA).next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql", "MOVE VERTEX " + rid + " TO BUCKET:testMoveBucket_extra")) {
+      assertThat(rs.hasNext()).isTrue();
+      final Result moved = rs.next();
+      assertThat(moved.getElement().get().getIdentity().getBucketId())
+          .isEqualTo(database.getSchema().getBucketByName("testMoveBucket_extra").getFileId());
+      assertThat(rs.hasNext()).isFalse();
+    }
+  }
+
+  /**
+   * Regression test for issue #4461: the SET/REMOVE/MERGE/CONTENT operations must be applied to the moved (re-created)
+   * vertex. Previously they were silently applied to the stale source record and lost.
+   */
+  @Test
+  void moveVertexWithUpdateOperations() {
+    final String typeA = "testMoveOpsA";
+    final String typeB = "testMoveOpsB";
+    database.getSchema().createVertexType(typeA);
+    database.getSchema().createVertexType(typeB);
+    database.setAutoTransaction(true);
+
+    // SET
+    String rid = database.command("sql", "create vertex " + typeA + " set somefield = 0").next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql",
+        "MOVE VERTEX (SELECT FROM " + rid + ") TO TYPE:" + typeB + " SET somefield = 1")) {
+      assertThat(rs.next().<Integer>getProperty("somefield")).isEqualTo(1);
+    }
+
+    // REMOVE
+    rid = database.command("sql", "create vertex " + typeA + " set somefield = 0").next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql",
+        "MOVE VERTEX (SELECT FROM " + rid + ") TO TYPE:" + typeB + " REMOVE somefield")) {
+      assertThat(rs.next().hasProperty("somefield")).isFalse();
+    }
+
+    // MERGE
+    rid = database.command("sql", "create vertex " + typeA + " set somefield = 0").next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql",
+        "MOVE VERTEX (SELECT FROM " + rid + ") TO TYPE:" + typeB + " MERGE {\"somefield\": 9}")) {
+      assertThat(rs.next().<Integer>getProperty("somefield")).isEqualTo(9);
+    }
+
+    // CONTENT
+    rid = database.command("sql", "create vertex " + typeA + " set somefield = 0").next().getIdentity().get().toString();
+    try (final ResultSet rs = database.command("sql",
+        "MOVE VERTEX (SELECT FROM " + rid + ") TO TYPE:" + typeB + " CONTENT {\"newfield\": 7}")) {
+      final Result moved = rs.next();
+      assertThat(moved.<Integer>getProperty("newfield")).isEqualTo(7);
+      assertThat(moved.hasProperty("somefield")).isFalse();
+    }
+  }
 }