#1534 Fix ClassCastException in BinaryComparator for TYPE_BINARY comparisons (#2762)

Co-authored-by: robfrank <413587+robfrank@users.noreply.github.com>

Author: Copilot

engine/src/main/java/com/arcadedb/serializer/BinaryComparator.java

@@ -289,7 +289,21 @@ public int compare(final Object value1, final byte type1, final Object value2, f
     case BinaryTypes.TYPE_BINARY: {
       switch (type2) {
       case BinaryTypes.TYPE_BINARY: {
-        return ((Binary) value1).compareTo((Binary) value2);
+        // Handle both byte[] and Binary objects
+        if (value1 instanceof byte[] bytes1) {
+          if (value2 instanceof byte[] bytes2) {
+            return UnsignedBytesComparator.BEST_COMPARATOR.compare(bytes1, bytes2);
+          } else if (value2 instanceof Binary binary2) {
+            return -compareBytes(binary2.getContent(), bytes1);
+          }
+        } else if (value1 instanceof Binary binary1) {
+          if (value2 instanceof byte[] bytes2) {
+            return compareBytes(binary1.getContent(), bytes2);
+          } else if (value2 instanceof Binary binary2) {
+            return binary1.compareTo(binary2);
+          }
+        }
+        throw new IllegalArgumentException("Invalid binary type for comparison: " + value1.getClass() + " and " + value2.getClass());
       }
       }
       throw new UnsupportedOperationException("Comparing binary types");

engine/src/test/java/com/arcadedb/index/BinaryIndexTest.java

@@ -0,0 +1,114 @@
+/*
+ * 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.index;
+
+import com.arcadedb.TestHelper;
+import com.arcadedb.database.Database;
+import com.arcadedb.schema.Schema;
+import com.arcadedb.schema.Type;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class BinaryIndexTest extends TestHelper {
+
+  @Test
+  public void testBinaryIndexInsertAndLookup() {
+    database.transaction(() -> {
+      if (database.getSchema().existsType("vt"))
+        database.getSchema().dropType("vt");
+
+      database.getSchema()
+          .getOrCreateVertexType("vt")
+          .getOrCreateProperty("prop", Type.BINARY)
+          .setMandatory(true)
+          .setNotNull(true)
+          .getOrCreateIndex(Schema.INDEX_TYPE.LSM_TREE, false);
+    });
+
+    database.transaction(() -> {
+      // First insert - SUCCESS
+      database.newVertex("vt").set("prop", new byte[]{1, 2, 3}).save();
+    });
+
+    database.transaction(() -> {
+      // Lookup - should work
+      try {
+        final IndexCursor results = database.lookupByKey("vt", "prop", new byte[]{1, 2, 3});
+        assertThat(results.hasNext()).as("Should find the inserted vertex").isTrue();
+      } catch (Exception e) {
+        fail("Lookup failed with exception", e);
+      }
+    });
+
+    database.transaction(() -> {
+      // Second insert - should also work
+      database.newVertex("vt").set("prop", new byte[]{1, 2, 3}).save();
+    });
+
+    database.transaction(() -> {
+      // Third insert - should also work
+      database.newVertex("vt").set("prop", new byte[]{1, 2, 3}).save();
+    });
+  }
+
+  @Test
+  public void testBinaryIndexAfterReopen() {
+    database.transaction(() -> {
+      if (database.getSchema().existsType("vt"))
+        database.getSchema().dropType("vt");
+
+      database.getSchema()
+          .getOrCreateVertexType("vt")
+          .getOrCreateProperty("prop", Type.BINARY)
+          .setMandatory(true)
+          .setNotNull(true)
+          .getOrCreateIndex(Schema.INDEX_TYPE.LSM_TREE, false);
+    });
+
+    database.transaction(() -> {
+      database.newVertex("vt").set("prop", new byte[]{1, 2, 3}).save();
+      database.newVertex("vt").set("prop", new byte[]{4, 5, 6}).save();
+    });
+
+    // Close and reopen the database
+    database.close();
+    database = factory.open();
+
+    database.transaction(() -> {
+      // Should work after reopening
+      try {
+        database.newVertex("vt").set("prop", new byte[]{7, 8, 9}).save();
+      } catch (Exception e) {
+        fail("Failed to insert after reopen", e);
+      }
+    });
+
+    database.transaction(() -> {
+      // Lookup should work
+      try {
+        final IndexCursor results = database.lookupByKey("vt", "prop", new byte[]{1, 2, 3});
+        assertThat(results.hasNext()).as("Should find the vertex after reopen").isTrue();
+      } catch (Exception e) {
+        fail("Lookup failed after reopen", e);
+      }
+    });
+  }
+}