Enable tests to run in parallel by default

CLAUDE.md

@@ -101,7 +101,10 @@ cd package
 ### Testing Commands
 - **Run specific test class**: `mvn test -Dtest=ClassName`
 - **Run tests with specific pattern**: `mvn test -Dtest="*Pattern*"`
+- **Run without slow/benchmark tests**: `mvn test -pl engine -DskipITs -Dgroups='!slow,!benchmark'`
+- **Override fork count** (e.g. all cores): `mvn test -Dforkcount=1C`
 - **Performance tests**: Located in `src/test/java/performance/` packages
+- **Parallel execution**: enabled by default - classes run concurrently across JVM forks; methods within a class run sequentially. Tests that mutate `GlobalConfiguration` are annotated `@ResourceLock("GlobalConfiguration")` to serialize with each other.
 
 ## Codebase Navigation Map
 

CONTRIBUTING.md

@@ -115,6 +115,26 @@ Build and run default tests:
 $ mvn clean install
 ```
 
+Tests run in parallel by default: classes execute concurrently across multiple JVM forks (`forkCount=0.5C`, i.e. half the available CPU cores). No extra flags needed.
+
+Run only unit tests for the engine module, skipping slow/benchmark tests:
+
+```shell
+$ mvn test -pl engine -DskipITs -Dgroups='!slow,!benchmark'
+```
+
+Override the number of parallel JVM forks (e.g. use all cores):
+
+```shell
+$ mvn test -pl engine -DskipITs -Dforkcount=1C
+```
+
+Run a single test class:
+
+```shell
+$ mvn test -pl engine -Dtest=MyTestClass -DskipITs
+```
+
 To run additional integration test locally use:
 
 ```shell

engine/src/main/java/com/arcadedb/GlobalConfiguration.java

@@ -42,20 +42,19 @@ public enum GlobalConfiguration {
   // ENVIRONMENT
   DUMP_CONFIG_AT_STARTUP("arcadedb.dumpConfigAtStartup", SCOPE.JVM, "Dumps the configuration at startup", Boolean.class, false,
       value -> {
-        //dumpConfiguration(System.out);
-
-        try {
-          final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-          dumpConfiguration(new PrintStream(buffer));
-          if (LogManager.instance() != null)
-            LogManager.instance().log(buffer, Level.WARNING, new String(buffer.toByteArray()));
-          else
-            System.out.println(new String(buffer.toByteArray()));
+        if (Boolean.TRUE.equals(value))
+          try {
+            final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+            dumpConfiguration(new PrintStream(buffer));
+            if (LogManager.instance() != null)
+              LogManager.instance().log(buffer, Level.WARNING, new String(buffer.toByteArray()));
+            else
+              System.out.println(new String(buffer.toByteArray()));
 
-          buffer.close();
-        } catch (IOException e) {
-          System.out.println("Error on printing initial configuration to log (error=" + e + ")");
-        }
+            buffer.close();
+          } catch (IOException e) {
+            System.out.println("Error on printing initial configuration to log (error=" + e + ")");
+          }
 
         return value;
       }),

engine/src/main/java/com/arcadedb/function/coll/CollInsert.java

@@ -57,7 +57,13 @@ public Object execute(final Object[] args, final CommandContext context) {
     final List<Object> list = asList(args[0]);
     if (list == null)
       return null;
+    if (args[1] == null)
+      return null;
     final int index = ((Number) args[1]).intValue();
+    if (index < 0)
+      throw new CommandExecutionException("coll.insert() does not support negative index: " + index);
+    if (index > list.size())
+      throw new CommandExecutionException("coll.insert() index " + index + " is out of range for list of size " + list.size());
     final List<Object> result = new ArrayList<>(list);
     result.add(index, args[2]);
     return result;

engine/src/main/java/com/arcadedb/function/coll/CollRemove.java

@@ -58,9 +58,13 @@ public Object execute(final Object[] args, final CommandContext context) {
     final List<Object> list = asList(args[0]);
     if (list == null)
       return null;
+    if (args[1] == null)
+      return null;
 
     final int index = ((Number) args[1]).intValue();
-    if (index < 0 || index >= list.size())
+    if (index < 0)
+      throw new CommandExecutionException("coll.remove() does not support negative index: " + index);
+    if (index >= list.size())
       throw new CommandExecutionException("coll.remove() index " + index + " is out of range for list of size " + list.size());
     final int count = args.length > 2 ? ((Number) args[2]).intValue() : 1;
     final List<Object> result = new ArrayList<>(list);

engine/src/main/java/com/arcadedb/function/geo/CypherPointDistanceFunction.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2021-present Arcade Data Ltd ([email protected])
+ *
+ * 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 ([email protected])
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.function.geo;
+
+import com.arcadedb.exception.CommandExecutionException;
+import com.arcadedb.function.StatelessFunction;
+import com.arcadedb.query.sql.executor.CommandContext;
+
+import java.util.Map;
+
+/**
+ * Cypher {@code point.distance(point1, point2)} function.
+ *
+ * <p>Computes the distance between two points. Uses Haversine formula for WGS-84
+ * geographic points (result in meters), and Euclidean distance for Cartesian points.</p>
+ */
+public class CypherPointDistanceFunction implements StatelessFunction {
+  private static final double EARTH_RADIUS_M = 6371000.0;
+
+  @Override
+  public String getName() {
+    return "point.distance";
+  }
+
+  @Override
+  public Object execute(final Object[] args, final CommandContext context) {
+    if (args == null || args.length != 2)
+      throw new CommandExecutionException("point.distance() requires exactly 2 arguments");
+    if (args[0] == null || args[1] == null)
+      return null;
+    if (!(args[0] instanceof Map) || !(args[1] instanceof Map))
+      throw new CommandExecutionException("point.distance() arguments must be point values (maps)");
+    final Map<?, ?> p1 = (Map<?, ?>) args[0];
+    final Map<?, ?> p2 = (Map<?, ?>) args[1];
+
+    // WGS-84: use Haversine formula
+    if (p1.containsKey("longitude") && p1.containsKey("latitude") &&
+        p2.containsKey("longitude") && p2.containsKey("latitude"))
+      return haversineDistance(
+          ((Number) p1.get("latitude")).doubleValue(), ((Number) p1.get("longitude")).doubleValue(),
+          ((Number) p2.get("latitude")).doubleValue(), ((Number) p2.get("longitude")).doubleValue());
+
+    // Cartesian: use Euclidean distance
+    final Number x1n = (Number) p1.get("x");
+    final Number y1n = (Number) p1.get("y");
+    final Number x2n = (Number) p2.get("x");
+    final Number y2n = (Number) p2.get("y");
+    if (x1n == null || y1n == null || x2n == null || y2n == null)
+      return null;
+    final double dx = x2n.doubleValue() - x1n.doubleValue();
+    final double dy = y2n.doubleValue() - y1n.doubleValue();
+    double sumSq = dx * dx + dy * dy;
+    final Number z1n = (Number) p1.get("z");
+    final Number z2n = (Number) p2.get("z");
+    if (z1n != null && z2n != null) {
+      final double dz = z2n.doubleValue() - z1n.doubleValue();
+      sumSq += dz * dz;
+    }
+    return Math.sqrt(sumSq);
+  }
+
+  private double haversineDistance(final double lat1, final double lon1, final double lat2, final double lon2) {
+    final double dLat = Math.toRadians(lat2 - lat1);
+    final double dLon = Math.toRadians(lon2 - lon1);
+    final double a = Math.pow(Math.sin(dLat / 2), 2)
+        + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+        * Math.pow(Math.sin(dLon / 2), 2);
+    return 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)) * EARTH_RADIUS_M;
+  }
+}

engine/src/main/java/com/arcadedb/function/geo/CypherPointFunction.java

@@ -20,19 +20,23 @@
 
 import com.arcadedb.exception.CommandExecutionException;
 import com.arcadedb.function.StatelessFunction;
-import com.arcadedb.function.sql.geo.GeoUtils;
-import com.arcadedb.function.sql.geo.LightweightPoint;
 import com.arcadedb.query.sql.executor.CommandContext;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+
 /**
- * Cypher {@code point(lat, lon)} function.
- *
- * <p>Constructs a spatial point from latitude and longitude. Following Cypher/Neo4j convention,
- * the first argument is latitude and the second is longitude. The point is stored internally
- * using the spatial4j convention (x=longitude, y=latitude) so that spatial distance functions
- * such as {@code geo.distance} operate correctly.</p>
+ * Cypher {@code point(map)} function.
  *
- * <p>Usage: {@code point(<latitude>, <longitude>)}</p>
+ * <p>Constructs a point from a map of coordinate properties. Supports:</p>
+ * <ul>
+ *   <li>WGS-84 2D: {@code point({longitude: x, latitude: y})}</li>
+ *   <li>WGS-84 3D: {@code point({longitude: x, latitude: y, height: z})}</li>
+ *   <li>Cartesian 2D: {@code point({x: a, y: b})}</li>
+ *   <li>Cartesian 3D: {@code point({x: a, y: b, z: c})}</li>
+ * </ul>
+ * <p>The returned map contains the coordinate keys and a {@code crs} field indicating
+ * the coordinate reference system.</p>
  */
 public class CypherPointFunction implements StatelessFunction {
   @Override
@@ -42,13 +46,84 @@ public String getName() {
 
   @Override
   public Object execute(final Object[] args, final CommandContext context) {
-    if (args == null || args.length < 2)
-      throw new CommandExecutionException("point() requires latitude and longitude as parameters");
-    if (args[0] == null || args[1] == null)
+    if (args == null || args.length == 0 || args.length > 2)
+      throw new CommandExecutionException("point() requires either one map argument (point({...})) or two numeric arguments (point(latitude, longitude))");
+
+    // 2-arg positional form: point(latitude, longitude) → WGS-84 2D
+    if (args.length == 2) {
+      if (args[0] == null || args[1] == null)
+        return null;
+      if (!(args[0] instanceof Number) || !(args[1] instanceof Number))
+        throw new CommandExecutionException("point() with two arguments requires numeric latitude and longitude");
+      final double lat = ((Number) args[0]).doubleValue();
+      final double lon = ((Number) args[1]).doubleValue();
+      final Map<String, Object> result = new LinkedHashMap<>();
+      result.put("latitude", lat);
+      result.put("longitude", lon);
+      result.put("x", lon);
+      result.put("y", lat);
+      result.put("crs", "WGS-84");
+      result.put("srid", 4326);
+      return result;
+    }
+
+    if (args[0] == null)
       return null;
-    final double lat = GeoUtils.getDoubleValue(args[0]);
-    final double lon = GeoUtils.getDoubleValue(args[1]);
-    // Store as LightweightPoint(x=longitude, y=latitude) per spatial4j convention
-    return new LightweightPoint(lon, lat);
+    if (!(args[0] instanceof Map))
+      throw new CommandExecutionException("point() argument must be a map with coordinate properties");
+    final Map<?, ?> map = (Map<?, ?>) args[0];
+
+    final Map<String, Object> result = new LinkedHashMap<>();
+
+    if (map.containsKey("longitude") || map.containsKey("latitude")) {
+      // WGS-84 coordinate system
+      final Object lon = map.get("longitude");
+      final Object lat = map.get("latitude");
+      if (lon == null || lat == null)
+        return null;
+      final double x = ((Number) lon).doubleValue();
+      final double y = ((Number) lat).doubleValue();
+      result.put("longitude", x);
+      result.put("latitude", y);
+      result.put("x", x);
+      result.put("y", y);
+      addOptionalZ(result, map);
+      result.put("crs", result.containsKey("z") ? "WGS-84-3D" : "WGS-84");
+      result.put("srid", result.containsKey("z") ? 4979 : 4326);
+    } else if (map.containsKey("x") || map.containsKey("y")) {
+      // Cartesian coordinate system
+      final Object xv = map.get("x");
+      final Object yv = map.get("y");
+      if (xv == null || yv == null)
+        return null;
+      final double x = ((Number) xv).doubleValue();
+      final double y = ((Number) yv).doubleValue();
+      result.put("x", x);
+      result.put("y", y);
+      addOptionalZ(result, map);
+      final Object crsObj = map.get("crs");
+      if (crsObj != null)
+        result.put("crs", crsObj.toString());
+      else
+        result.put("crs", result.containsKey("z") ? "cartesian-3D" : "cartesian");
+      if (map.containsKey("srid"))
+        result.put("srid", ((Number) map.get("srid")).intValue());
+    } else {
+      throw new CommandExecutionException("point() map must contain x/y or longitude/latitude properties");
+    }
+
+    return result;
+  }
+
+  private void addOptionalZ(final Map<String, Object> result, final Map<?, ?> map) {
+    if (map.containsKey("z")) {
+      final Object zv = map.get("z");
+      if (zv != null)
+        result.put("z", ((Number) zv).doubleValue());
+    } else if (map.containsKey("height")) {
+      final Object hv = map.get("height");
+      if (hv != null)
+        result.put("z", ((Number) hv).doubleValue());
+    }
   }
 }

engine/src/main/java/com/arcadedb/function/math/RoundFunction.java

@@ -42,7 +42,7 @@ public String getName() {
 
   @Override
   public Object execute(final Object[] args, final CommandContext context) {
-    if (args.length < 1 || args.length > 2)
+    if (args.length < 1 || args.length > 3)
       throw new CommandExecutionException("round() requires one or two arguments");
 
     if (args[0] == null)
@@ -61,7 +61,7 @@ public Object execute(final Object[] args, final CommandContext context) {
       return (double) Math.round(value);
     }
 
-    // round(value, precision)
+    // round(value, precision) or round(value, precision, mode)
     if (args[1] == null)
       return null;
 
@@ -70,7 +70,22 @@ public Object execute(final Object[] args, final CommandContext context) {
 
     final int precision = ((Number) args[1]).intValue();
 
-    final BigDecimal bd = BigDecimal.valueOf(value).setScale(precision, RoundingMode.HALF_UP);
+    RoundingMode mode = RoundingMode.HALF_UP;
+    if (args.length == 3 && args[2] != null) {
+      final String modeStr = args[2].toString().toUpperCase().replace(" ", "_");
+      mode = switch (modeStr) {
+        case "UP" -> RoundingMode.UP;
+        case "DOWN" -> RoundingMode.DOWN;
+        case "CEILING" -> RoundingMode.CEILING;
+        case "FLOOR" -> RoundingMode.FLOOR;
+        case "HALF_UP" -> RoundingMode.HALF_UP;
+        case "HALF_DOWN" -> RoundingMode.HALF_DOWN;
+        case "HALF_EVEN" -> RoundingMode.HALF_EVEN;
+        default -> throw new CommandExecutionException("round() unknown rounding mode: " + args[2]);
+      };
+    }
+
+    final BigDecimal bd = BigDecimal.valueOf(value).setScale(precision, mode);
     return bd.doubleValue();
   }
 }

engine/src/main/java/com/arcadedb/function/sql/geo/GeoUtils.java

@@ -32,6 +32,7 @@
 import org.locationtech.spatial4j.shape.jts.JtsGeometry;
 
 import java.util.Locale;
+import java.util.Map;
 
 /**
  * Geospatial utility class.
@@ -69,6 +70,21 @@ public static Shape parseGeometry(final Object value) {
       return null;
     if (value instanceof Shape shape)
       return shape;
+    // Cypher point() returns a Map with x/y or longitude/latitude keys
+    if (value instanceof Map<?, ?> map) {
+      double x;
+      double y;
+      if (map.containsKey("x") && map.containsKey("y")) {
+        x = ((Number) map.get("x")).doubleValue();
+        y = ((Number) map.get("y")).doubleValue();
+      } else if (map.containsKey("longitude") && map.containsKey("latitude")) {
+        x = ((Number) map.get("longitude")).doubleValue();
+        y = ((Number) map.get("latitude")).doubleValue();
+      } else {
+        throw new IllegalArgumentException("Cannot parse geometry from map: missing x/y or longitude/latitude keys");
+      }
+      return SPATIAL_CONTEXT.getShapeFactory().pointXY(x, y);
+    }
     final String wkt = value.toString().trim();
     if (wkt.isEmpty())
       return null;

engine/src/main/java/com/arcadedb/function/sql/math/SQLFunctionStandardDeviation.java

@@ -40,6 +40,6 @@ public Object getResult() {
     final Object variance = super.getResult();
     if (variance != null)
       return Math.sqrt((Double) variance);
-    return null;
+    return 0.0;
   }
 }