Add and for list and dict

Author: fileames

libs/oracledb/langchain_oracledb/vectorstores/oraclevs.py

@@ -12,6 +12,7 @@
 import functools
 import hashlib
 import inspect
+import json
 import logging
 import os
 import re
@@ -93,6 +94,9 @@
 def _get_comparison_string(
     oper: str, value: Any, bind_variables: List[str]
 ) -> tuple[str, str]:
+    if oper not in COMPARISON_MAP:
+        raise ValueError(f"Invalid operator: {oper}")
+
     # usual two sided operator case
     if COMPARISON_MAP[oper] != "":
         bind_l = len(bind_variables)
@@ -194,26 +198,30 @@ def _generate_condition(
 
     if not isinstance(value, (dict, list, tuple)):
         # scalar-equality Clause
-        bind_l = f":value{len(bind_variables)}"
+        bind = f":value{len(bind_variables)}"
         bind_variables.append(value)
 
-        return SINGLE_MASK.format(key=metadata_key, oper="==", value_bind=bind_l)
+        return SINGLE_MASK.format(key=metadata_key, oper="==", value_bind=bind)
 
     elif isinstance(value, dict):
         # all values are filters
         result: str
         passings: str
 
         # comparison operator keys
-        if len(value.keys() - COMPARISON_MAP.keys()) == 0:
+        if all(value_key.startswith("$") for value_key in value.keys()):
             not_dict = {}
 
             passing_values = []
             comparison_values = []
 
             for k, v in value.items():
                 # if need to negate, cannot combine in single JSON_EXISTS
-                if k in NOT_OPERS:
+                if (
+                    k in NOT_OPERS
+                    or (k == "$eq" and isinstance(v, (list, dict)))
+                    or (k == "$ne" and isinstance(v, (list, dict)))
+                ):
                     not_dict[k] = v
                     continue
 
@@ -255,7 +263,7 @@ def _generate_condition(
                             f"NOT (JSON_EXISTS(metadata, '$.{metadata_key}'))"
                         )
 
-                else:  # for now only $nin
+                elif k == "$nin":  # for now only $nin
                     result, passings = _get_comparison_string(k, v, bind_variables)
 
                     all_conditions.append(
@@ -265,6 +273,28 @@ def _generate_condition(
                         )
                     )
 
+                elif k == "$eq":
+                    bind_l = len(bind_variables)
+                    bind_variables.append(json.dumps(v))
+
+                    all_conditions.append(
+                        "JSON_EQUAL("
+                        f"    JSON_QUERY(metadata, '$.{metadata_key}' ),"
+                        f"    JSON(:value{bind_l})"
+                        ")"
+                    )
+
+                elif k == "$ne":
+                    bind_l = len(bind_variables)
+                    bind_variables.append(json.dumps(v))
+
+                    all_conditions.append(
+                        "NOT (JSON_EQUAL("
+                        f"    JSON_QUERY(metadata, '$.{metadata_key}' ),"
+                        f"    JSON(:value{bind_l})"
+                        "))"
+                    )
+
             res = " AND ".join(all_conditions)
 
             if len(all_conditions) > 1:

libs/oracledb/tests/integration_tests/vectorstores/test_oraclevs.py

@@ -2649,30 +2649,52 @@ def model1(_) -> list[float]:  # type: ignore[no-untyped-def]
 
     vs.add_texts(texts, metadatas)
 
-    """SELECT json_exists('{
-            "id": "1",
-            "name": "Jason",
-            "age": 45,
-            "address": [
-                {
-                    "street": "25 A street",
-                    "city": "Mono Vista",
-                    "zip": 94088,
-                    "state": "CA",
-                }
-            ],
-            "drinks": "tea",
-        }', '$.name?(@ in ("json","b"))');"""
-
     filter_res: list[tuple[dict, list[str]]] = [
         ({"drinks": {"$exists": True}}, ["1", "3"]),
         ({"address.zip": 94088}, ["1"]),
         ({"name": {"$eq": "Jason"}}, ["1"]),
         ({"drinks": {"$ne": "tea"}}, ["3"]),  # exits and not equal
+        ({"drinks": {"$eq": ["soda", "tea"]}}, ["3"]),
+        ({"drinks": {"$ne": ["soda", "tea"]}}, ["1"]),
+        (
+            {
+                "address[0]": {
+                    "$eq": {
+                        "street": "25 A street",
+                        "city": "Mono Vista",
+                        "zip": 94088,
+                        "state": "CA",
+                    }
+                }
+            },
+            ["1"],
+        ),
+        (
+            {
+                "address[0]": {
+                    "$ne": {
+                        "street": "25 A street",
+                        "city": "Mono Vista",
+                        "zip": 94088,
+                        "state": "CA",
+                    }
+                }
+            },
+            ["2"],
+        ),
         (
             {"$or": [{"drinks": {"$exists": False}}, {"drinks": {"$ne": "tea"}}]},
             ["2", "3"],
         ),
+        (
+            {
+                "$or": [
+                    {"drinks": {"$exists": False}},
+                    {"drinks": {"$ne": ["soda", "tea"]}},
+                ]
+            },
+            ["1", "2"],
+        ),
         ({"age": {"$gt": 45, "$lt": 55}}, ["2"]),
         ({"age": {"$gt": 45}}, ["2", "3"]),
         ({"age": {"$lt": 55}}, ["1", "2"]),
@@ -2754,6 +2776,10 @@ def model1(_) -> list[float]:  # type: ignore[no-untyped-def]
         _f = {"ss')--": "HELLOE"}
         result = vs.similarity_search("Hello", k=3, db_filter=_f)
 
+    with pytest.raises(ValueError, match="Invalid operator"):
+        _f = {"drinks": {"$neq": ["soda", "tea"]}}
+        result = vs.similarity_search("Hello", k=3, db_filter=_f)
+
     drop_table_purge(connection, "TB10")
 
 
@@ -2821,10 +2847,47 @@ def model1(_) -> list[float]:  # type: ignore[no-untyped-def]
         ({"address.zip": 94088}, ["1"]),
         ({"name": {"$eq": "Jason"}}, ["1"]),
         ({"drinks": {"$ne": "tea"}}, ["3"]),  # exits and not equal
+        ({"drinks": {"$eq": ["soda", "tea"]}}, ["3"]),
+        ({"drinks": {"$ne": ["soda", "tea"]}}, ["1"]),
+        (
+            {
+                "address[0]": {
+                    "$eq": {
+                        "street": "25 A street",
+                        "city": "Mono Vista",
+                        "zip": 94088,
+                        "state": "CA",
+                    }
+                }
+            },
+            ["1"],
+        ),
+        (
+            {
+                "address[0]": {
+                    "$ne": {
+                        "street": "25 A street",
+                        "city": "Mono Vista",
+                        "zip": 94088,
+                        "state": "CA",
+                    }
+                }
+            },
+            ["2"],
+        ),
         (
             {"$or": [{"drinks": {"$exists": False}}, {"drinks": {"$ne": "tea"}}]},
             ["2", "3"],
         ),
+        (
+            {
+                "$or": [
+                    {"drinks": {"$exists": False}},
+                    {"drinks": {"$ne": ["soda", "tea"]}},
+                ]
+            },
+            ["1", "2"],
+        ),
         ({"age": {"$gt": 45, "$lt": 55}}, ["2"]),
         ({"age": {"$gt": 45}}, ["2", "3"]),
         ({"age": {"$lt": 55}}, ["1", "2"]),
@@ -2906,4 +2969,8 @@ def model1(_) -> list[float]:  # type: ignore[no-untyped-def]
         _f = {"ss')--": "HELLOE"}
         result = await vs.asimilarity_search("Hello", k=3, db_filter=_f)
 
+    with pytest.raises(ValueError, match="Invalid operator"):
+        _f = {"drinks": {"$neq": ["soda", "tea"]}}
+        result = await vs.asimilarity_search("Hello", k=3, db_filter=_f)
+
     await adrop_table_purge(connection, "TB10")