Merge pull request #24 from microsoft/fixes

Fixes

Author: niclasko

flowquery-py/src/graph/relationship.py

@@ -167,7 +167,7 @@ def find_match(id_: str, h: int) -> bool:
         follow_id = 'left_id' if is_left else 'right_id'
         while self._data and find_match(left_id, hop):
             data = self._data.current(hop)
-            if data and self._hops and hop >= self._hops.min:
+            if data and self._hops and hop + 1 >= self._hops.min:
                 self.set_value(self)
                 if not self._matches_properties(hop):
                     continue
@@ -178,6 +178,10 @@ def find_match(id_: str, h: int) -> bool:
                 if self._hops and hop + 1 < self._hops.max:
                     await self.find(data[follow_id], hop + 1)
                 self._matches.pop()
+            elif data and self._hops:
+                # Below minimum hops: traverse the edge without yielding a match
+                if follow_id in data:
+                    await self.find(data[follow_id], hop + 1)
 
         # Restore original source node
         self._source = original

flowquery-py/src/parsing/expressions/__init__.py

@@ -13,13 +13,15 @@
     Equals,
     GreaterThan,
     GreaterThanOrEqual,
+    In,
     Is,
     LessThan,
     LessThanOrEqual,
     Modulo,
     Multiply,
     Not,
     NotEquals,
+    NotIn,
     Operator,
     Or,
     Power,
@@ -54,4 +56,6 @@
     "Or",
     "Not",
     "Is",
+    "In",
+    "NotIn",
 ]

flowquery-py/src/parsing/expressions/operator.py

@@ -167,3 +167,105 @@ def __init__(self) -> None:
 
     def value(self) -> int:
         return 1 if self.lhs.value() == self.rhs.value() else 0
+
+
+class IsNot(Operator):
+    def __init__(self) -> None:
+        super().__init__(-1, True)
+
+    def value(self) -> int:
+        return 1 if self.lhs.value() != self.rhs.value() else 0
+
+
+class In(Operator):
+    def __init__(self) -> None:
+        super().__init__(-1, True)
+
+    def value(self) -> int:
+        lst = self.rhs.value()
+        if not isinstance(lst, list):
+            raise ValueError("Right operand of IN must be a list")
+        return 1 if self.lhs.value() in lst else 0
+
+
+class NotIn(Operator):
+    def __init__(self) -> None:
+        super().__init__(-1, True)
+
+    def value(self) -> int:
+        lst = self.rhs.value()
+        if not isinstance(lst, list):
+            raise ValueError("Right operand of NOT IN must be a list")
+        return 0 if self.lhs.value() in lst else 1
+
+
+class Contains(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("CONTAINS requires string operands")
+        return 1 if search in s else 0
+
+
+class NotContains(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("NOT CONTAINS requires string operands")
+        return 0 if search in s else 1
+
+
+class StartsWith(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("STARTS WITH requires string operands")
+        return 1 if s.startswith(search) else 0
+
+
+class NotStartsWith(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("NOT STARTS WITH requires string operands")
+        return 0 if s.startswith(search) else 1
+
+
+class EndsWith(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("ENDS WITH requires string operands")
+        return 1 if s.endswith(search) else 0
+
+
+class NotEndsWith(Operator):
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def value(self) -> int:
+        s = self.lhs.value()
+        search = self.rhs.value()
+        if not isinstance(s, str) or not isinstance(search, str):
+            raise ValueError("NOT ENDS WITH requires string operands")
+        return 0 if s.endswith(search) else 1

flowquery-py/src/parsing/functions/__init__.py

@@ -30,6 +30,7 @@
 from .schema import Schema
 from .size import Size
 from .split import Split
+from .string_distance import StringDistance
 from .stringify import Stringify
 
 # Built-in functions
@@ -68,6 +69,7 @@
     "Round",
     "Size",
     "Split",
+    "StringDistance",
     "Stringify",
     "ToJson",
     "Type",

flowquery-py/src/parsing/functions/string_distance.py

@@ -0,0 +1,88 @@
+"""String distance function using Levenshtein distance."""
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+def _levenshtein_distance(a: str, b: str) -> float:
+    """Compute the normalized Levenshtein distance between two strings.
+
+    The Levenshtein distance is the minimum number of single-character edits
+    (insertions, deletions, or substitutions) required to change one string
+    into the other. The result is normalized to [0, 1] by dividing by the
+    length of the longer string.
+
+    Args:
+        a: First string
+        b: Second string
+
+    Returns:
+        The normalized Levenshtein distance (0 = identical, 1 = completely different)
+    """
+    m = len(a)
+    n = len(b)
+
+    # Both empty strings are identical
+    if m == 0 and n == 0:
+        return 0.0
+
+    # Create a matrix of size (m+1) x (n+1)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+    # Base cases: transforming empty string to/from a prefix
+    for i in range(m + 1):
+        dp[i][0] = i
+    for j in range(n + 1):
+        dp[0][j] = j
+
+    # Fill in the rest of the matrix
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            cost = 0 if a[i - 1] == b[j - 1] else 1
+            dp[i][j] = min(
+                dp[i - 1][j] + 1,       # deletion
+                dp[i][j - 1] + 1,       # insertion
+                dp[i - 1][j - 1] + cost  # substitution
+            )
+
+    # Normalize by the length of the longer string
+    return dp[m][n] / max(m, n)
+
+
+@FunctionDef({
+    "description": (
+        "Computes the normalized Levenshtein distance between two strings. "
+        "Returns a value in [0, 1] where 0 means identical and 1 means completely different."
+    ),
+    "category": "scalar",
+    "parameters": [
+        {"name": "string1", "description": "First string", "type": "string"},
+        {"name": "string2", "description": "Second string", "type": "string"}
+    ],
+    "output": {
+        "description": "Normalized Levenshtein distance (0 = identical, 1 = completely different)",
+        "type": "number",
+        "example": 0.43,
+    },
+    "examples": [
+        "RETURN string_distance('kitten', 'sitting')",
+        "WITH 'hello' AS a, 'hallo' AS b RETURN string_distance(a, b)"
+    ]
+})
+class StringDistance(Function):
+    """String distance function.
+
+    Computes the normalized Levenshtein distance between two strings.
+    Returns a value in [0, 1] where 0 means identical and 1 means completely different.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("string_distance")
+        self._expected_parameter_count = 2
+
+    def value(self) -> float:
+        str1 = self.get_children()[0].value()
+        str2 = self.get_children()[1].value()
+        if not isinstance(str1, str) or not isinstance(str2, str):
+            raise ValueError("Invalid arguments for string_distance function: both arguments must be strings")
+        return _levenshtein_distance(str1, str2)