Add support for advanced SQL features and improvements

client-java/distance-heuristics/src/main/java/org/evomaster/client/java/distance/heuristics/DistanceHelper.java

@@ -7,14 +7,15 @@
 import java.time.chrono.ChronoLocalDateTime;
 import java.util.Date;
 import java.util.Objects;
+import java.util.UUID;
 
 /**
  * All generic distance functions on JVM types should be defined here.
  * Recall the distinction between "distance" and "heuristic" terms in EvoMaster:
- *
+ * <p>
  * - distance: a value between 0 and MAX. If 0, constraint is solved.
  * - heuristic: a value between 0 and 1. If 0, constraint is NOT solved. If solved, value is 1.
- *
+ * <p>
  * The "distance"s are what usually used in literature.
  * However, in EvoMaster we need [0,1] "heuristic"s (due to the handling of Many Objective Optimization).
  */
@@ -44,23 +45,23 @@ public class DistanceHelper {
      * @param delta
      * @return
      */
-    public static double increasedDistance(double distance, double delta){
+    public static double increasedDistance(double distance, double delta) {
 
-        if(distance < 0){
+        if (distance < 0) {
             throw new IllegalArgumentException("Negative distance: " + distance);
         }
-        if(delta < 0){
+        if (delta < 0) {
             throw new IllegalArgumentException("Invalid negative delta: " + delta);
         }
-        if(delta == 0){
+        if (delta == 0) {
             throw new IllegalArgumentException("Meaningless 0 delta");
         }
 
-        if(Double.isInfinite(distance) || distance == Double.MAX_VALUE){
+        if (Double.isInfinite(distance) || distance == Double.MAX_VALUE) {
             return distance;
         }
 
-        if(distance > (Double.MAX_VALUE - delta)){
+        if (distance > (Double.MAX_VALUE - delta)) {
             return Double.MAX_VALUE;
         }
 
@@ -75,10 +76,10 @@ public static double increasedDistance(double distance, double delta){
      * @return
      */
     public static double addDistances(double a, double b) {
-        if(a < 0){
+        if (a < 0) {
             throw new IllegalArgumentException("Negative distance: " + a);
         }
-        if(b < 0){
+        if (b < 0) {
             throw new IllegalArgumentException("Negative distance: " + b);
         }
         double sum = a + b;
@@ -92,36 +93,37 @@ public static double addDistances(double a, double b) {
 
     /**
      * Return a h=[0,1] heuristics from a scaled distance, taking into account a starting base
+     *
      * @param base
      * @param distance
      * @return
      */
-    public static double heuristicFromScaledDistanceWithBase(double base, double distance){
+    public static double heuristicFromScaledDistanceWithBase(double base, double distance) {
 
-        if(base < 0 || base >= 1){
+        if (base < 0 || base >= 1) {
             throw new IllegalArgumentException("Invalid base: " + base);
         }
-        if(distance < 0){
+        if (distance < 0) {
             throw new IllegalArgumentException("Negative distance: " + distance);
         }
 
-        if(Double.isInfinite(distance) || distance == Double.MAX_VALUE){
+        if (Double.isInfinite(distance) || distance == Double.MAX_VALUE) {
             return base;
         }
 
-       return base + ((1 - base) / (distance + 1));
+        return base + ((1 - base) / (distance + 1));
     }
 
-    public static double scaleHeuristicWithBase(double heuristic, double base){
+    public static double scaleHeuristicWithBase(double heuristic, double base) {
 
-        if(heuristic < 0 || heuristic >= 1){
+        if (heuristic < 0 || heuristic >= 1) {
             throw new IllegalArgumentException("Invalid heuristic: " + base);
         }
-        if(base < 0 || base >= 1){
+        if (base < 0 || base >= 1) {
             throw new IllegalArgumentException("Invalid base: " + base);
         }
 
-        return base + ((1-base)*heuristic);
+        return base + ((1 - base) * heuristic);
     }
 
     public static int distanceToDigit(char c) {
@@ -144,7 +146,7 @@ public static int distanceToRange(int c, int minInclusive, int maxInclusive) {
 
         //1 of 2 will be necessarily a 0
         long dist = Math.max(diffAfter, 0) + Math.max(diffBefore, 0);
-        if(dist > Integer.MAX_VALUE){
+        if (dist > Integer.MAX_VALUE) {
             return Integer.MAX_VALUE;
         }
         assert (dist >= 0);
@@ -166,7 +168,7 @@ public static long getLeftAlignmentDistance(String a, String b) {
             dist += Math.abs(a.charAt(i) - b.charAt(i));
         }
 
-        if(dist < 0){
+        if (dist < 0) {
             dist = Long.MAX_VALUE; // overflow
         }
 
@@ -242,10 +244,10 @@ public static double getDistanceToEquality(LocalTime a, LocalTime b) {
 
     public static double getDistance(Object left, Object right) {
 
-        if(left == null && right == null){
+        if (left == null && right == null) {
             return 0;
         }
-        if(left == null || right == null){
+        if (left == null || right == null) {
             return Double.MAX_VALUE;
         }
 
@@ -330,4 +332,19 @@ public static double getDistance(Object left, Object right) {
 
         return distance;
     }
+
+    /**
+     * Computes the Hamming distance between two UUIDs. The Hamming distance is determined by
+     * counting the number of differing bits between the most and least significant bits
+     * of the two UUIDs.
+     *
+     * @param left the first UUID
+     * @param right the second UUID
+     * @return the Hamming distance between the two UUIDs
+     */
+    public static int getDistance(UUID left, UUID right) {
+        long diff1 = left.getMostSignificantBits() ^ right.getMostSignificantBits();
+        long diff2 = left.getLeastSignificantBits() ^ right.getLeastSignificantBits();
+        return Long.bitCount(diff1) + Long.bitCount(diff2);
+    }
 }

client-java/distance-heuristics/src/main/java/org/evomaster/client/java/distance/heuristics/TruthnessUtils.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 import java.util.Objects;
+import java.util.UUID;
 
 public class TruthnessUtils {
 
@@ -132,6 +133,7 @@ public static Truthness getEqualityTruthness(double a, double b) {
 
     /**
      * Returns a truthness value for comparing how close a length was to 0.
+     *
      * @param len a positive value for a length
      * @return a Truthness instance
      */
@@ -190,13 +192,13 @@ public static Truthness buildOrAggregationTruthness(Truthness... truthnesses) {
      * <p>
      * This method returns XOR(a,b) as (a AND NOT b) OR (NOT a AND b).
      *
-     * @param left the first Truthness instance
+     * @param left  the first Truthness instance
      * @param right the second Truthness instance
      * @return a new Truthness instance representing the XOR aggregation of the input Truthness instances
      */
     public static Truthness buildXorAggregationTruthness(Truthness left, Truthness right) {
-        Truthness leftAndNotRight = buildAndAggregationTruthness(left,right.invert());
-        Truthness notLeftAndRight = buildAndAggregationTruthness(left.invert(),right);
+        Truthness leftAndNotRight = buildAndAggregationTruthness(left, right.invert());
+        Truthness notLeftAndRight = buildAndAggregationTruthness(left.invert(), right);
         Truthness orAggregation = buildOrAggregationTruthness(leftAndNotRight, notLeftAndRight);
         return orAggregation;
     }
@@ -294,7 +296,7 @@ private static double trueOrAverageTrue(Truthness... truthnesses) {
      * and creates a Truthness instance where the `ofTrue` field is the scaled value and
      * the `ofFalse` field is set to 1.0.
      *
-     * @param base the base value used for scaling
+     * @param base          the base value used for scaling
      * @param ofTrueToScale the value to be scaled
      * @return a new Truthness instance with the scaled `ofTrue` value and `ofFalse` set to 1.0
      */
@@ -305,5 +307,16 @@ public static Truthness buildScaledTruthness(double base, double ofTrueToScale)
     }
 
 
+    public static Truthness getEqualityTruthness(UUID left, UUID right) {
+        Objects.requireNonNull(left);
+        Objects.requireNonNull(right);
+
+        double distance = DistanceHelper.getDistance(left, right);
+        double normalizedDistance = normalizeValue(distance);
+        return new Truthness(
+                1d - normalizedDistance,
+                !left.equals(right) ? 1d : 0d
+        );
+    }
 
 }

client-java/distance-heuristics/src/test/java/org/evomaster/client/java/distance/heuristics/DistanceHelperTest.java

@@ -2,6 +2,8 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.UUID;
+
 import static org.evomaster.client.java.distance.heuristics.DistanceHelper.*;
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -68,9 +70,33 @@ public void testDoubleOverflowsDistance() {
 
     @Test
     public void testDoubleMaxDistance() {
-        double upperBound = Double.MAX_VALUE  /2;
+        double upperBound = Double.MAX_VALUE / 2;
         double lowerBound = -upperBound;
         double distance = getDistanceToEquality(lowerBound, upperBound);
         assertEquals(Double.MAX_VALUE, distance);
     }
-}
+
+    @Test
+    public void testDistanceUUIDEquals() {
+        UUID left = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        UUID right = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        double distance = getDistance(left, right);
+        assertEquals(0, distance);
+    }
+
+    @Test
+    public void testDistanceUUIDNotEquals() {
+        UUID left = UUID.fromString("123e4567-e89b-12d3-a456-426614174001");
+        UUID right = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        double distance = getDistance(left, right);
+        assertEquals(1, distance);
+    }
+
+    @Test
+    public void testDistanceUUIDNotEqualsThree() {
+        UUID left = UUID.fromString("123e4567-e89b-12d3-a456-426614174003");
+        UUID right = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        double distance = getDistance(left, right);
+        assertEquals(2, distance);
+    }
+}

client-java/distance-heuristics/src/test/java/org/evomaster/client/java/distance/heuristics/TruthnessUtilsTest.java

@@ -0,0 +1,32 @@
+package org.evomaster.client.java.distance.heuristics;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.evomaster.client.java.distance.heuristics.TruthnessUtils.normalizeValue;
+import static org.junit.jupiter.api.Assertions.*;
+
+class TruthnessUtilsTest {
+
+    @Test
+    public void testGetEqualityTruthnessEqualsUUID() {
+        UUID left = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        UUID right = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        Truthness t = TruthnessUtils.getEqualityTruthness(left, right);
+        assertTrue(t.isTrue());
+        assertEquals(1.0, t.getOfTrue());
+        assertEquals(0.0, t.getOfFalse());
+    }
+
+    @Test
+    public void testGetEqualityTruthnessNotEqualsUUID() {
+        UUID left = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        UUID right = UUID.fromString("123e4567-e89b-12d3-a456-426614174001");
+        Truthness t = TruthnessUtils.getEqualityTruthness(left, right);
+        assertFalse(t.isTrue());
+        assertEquals(1.0 - normalizeValue(1), t.getOfTrue());
+        assertEquals(1.0, t.getOfFalse());
+    }
+
+}

client-java/sql/src/main/java/org/evomaster/client/java/sql/DataRow.java

@@ -9,6 +9,7 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static org.evomaster.client.java.sql.heuristic.SqlStringUtils.nullSafeEndsWithIgnoreCase;
 import static org.evomaster.client.java.sql.heuristic.SqlStringUtils.nullSafeEqualsIgnoreCase;
 
 /**
@@ -102,10 +103,10 @@ public Object getValueByName(String name, String table) {
          * since 'y','n','on','off', 'yes' and 'no'
          * are also considered boolean literals.
          */
-        if (n!=null && n.equalsIgnoreCase("true")) {
+        if (n != null && n.equalsIgnoreCase("true")) {
             return true;
         }
-        if (n!= null && n.equalsIgnoreCase("false")) {
+        if (n != null && n.equalsIgnoreCase("false")) {
             return false;
         }
 
@@ -128,11 +129,11 @@ public Object getValueByName(String name, String table) {
             boolean matchColumnName = nullSafeEqualsIgnoreCase(n, desc.getColumnName())
                     || nullSafeEqualsIgnoreCase(n, desc.getAliasColumnName());
 
-            if (!matchColumnName){
+            if (!matchColumnName) {
                 continue;
             }
             //no defined table, or exact match
-            if(t == null || t.isEmpty() || nullSafeEqualsIgnoreCase(t, desc.getTableName()) ){
+            if (t == null || t.isEmpty() || nullSafeEqualsIgnoreCase(t, desc.getTableName())) {
                 return getValue(i);
             }
             /*
@@ -141,20 +142,20 @@ there can be many unnamed tables (eg results of sub-selects)
                 with same column names. At this moment, we would not
                 be able to distinguish them
              */
-            if(nullSafeEqualsIgnoreCase(t, SqlNameContext.UNNAMED_TABLE)){
+            if (nullSafeEqualsIgnoreCase(t, SqlNameContext.UNNAMED_TABLE)) {
                 candidates.add(i);
             }
 
-            if(!t.contains(".") && desc.getTableName().toLowerCase().endsWith("."+t.toLowerCase())){
+            if (!t.contains(".") && nullSafeEndsWithIgnoreCase(desc.getTableName(), "." + t)) {
                 candidates.add(i);
             }
         }
 
-        if(candidates.size() > 1){
+        if (candidates.size() > 1) {
             SimpleLogger.uniqueWarn("More than one table candidate for: " + t);
         }
 
-        if(candidates.size() >= 1){
+        if (candidates.size() >= 1) {
             return getValue(candidates.get(0));
         }
 

client-java/sql/src/main/java/org/evomaster/client/java/sql/QueryResult.java

@@ -1,5 +1,6 @@
 package org.evomaster.client.java.sql;
 
+import net.sf.jsqlparser.statement.select.OrderByElement;
 import org.evomaster.client.java.controller.api.dto.database.operations.QueryResultDto;
 
 import java.lang.reflect.Method;
@@ -195,4 +196,26 @@ public String getTableName() {
         }
         return variableDescriptors.get(0).getTableName();
     }
+
+    /**
+     * Creates a new QueryResult containing only the first 'limit' rows
+     * of the current QueryResult.
+     *
+     * @param limit the maximum number of rows to include in the new QueryResult
+     * @return a new QueryResult with at most 'limit' rows
+     */
+    public QueryResult limit(long limit) {
+        if (limit < 0) {
+            throw new IllegalArgumentException("Limit must be non-negative");
+        }
+        if (limit >= rows.size()) {
+            return this;
+        }
+        QueryResult limitedResult = new QueryResult(this.variableDescriptors);
+        for (int i = 0; i < limit; i++) {
+            limitedResult.addRow(this.rows.get(i));
+        }
+        return limitedResult;
+    }
+
 }