FEAT:Support 5.1-Modified JSON_Haskey_Lookup (#459)

* removed deprecated fields

* modified json has_key lookup

* Enhanced code quality

* resolved conflict

* refactored the code

* refactored the json_haskey code

* refactored haskey code

* refactored the haskey function

* refactored  json function

---------

Co-authored-by: Gaurav Sharma <[email protected]>

Author: NandanaRaol

mssql/functions.py

@@ -300,106 +300,99 @@ def json_KeyTransformExact_process_rhs(self, compiler, connection):
         rhs_params = unquote_json_rhs(rhs_params)
     return rhs, rhs_params
 
-
 def json_KeyTransformIn(self, compiler, connection):
     lhs, _ = super(KeyTransformIn, self).process_lhs(compiler, connection)
     rhs, rhs_params = super(KeyTransformIn, self).process_rhs(compiler, connection)
 
     return (lhs + ' IN ' + rhs, unquote_json_rhs(rhs_params))
 
-# This handles the case where the JSON data comes from a table column (actual database data).
-# Also deals with hardcoded JSON string literal seperately, since handling differs for literals vs. table data
 def json_HasKeyLookup(self, compiler, connection):
     """
     Implementation of HasKey lookup for SQL Server.
-    Handles for both SQL Server 2022+ (using JSON_PATH_EXISTS) and older versions (using OPENJSON).
+
+    Supports two methods depending on SQL Server version:
+    - SQL Server 2022+: Uses JSON_PATH_EXISTS function
+    - Older versions: Uses JSON_VALUE IS NOT NULL
     """
-    # Determine the JSON path for the left-hand side (lhs).
-    # If dealing with a nested JSON structure, use KeyTransform to extract the path.
+
+    def _combine_conditions(conditions):
+        # Combine multiple conditions using the logical operator if present, otherwise return the first condition
+        if hasattr(self, 'logical_operator') and self.logical_operator:
+            logical_op = f" {self.logical_operator} "
+            return f"({logical_op.join(conditions)})"
+        else:
+            return conditions[0]
+
+    # Process JSON path from the left-hand side.
     if isinstance(self.lhs, KeyTransform):
+        # If lhs is a KeyTransform, preprocess to get SQL and JSON path
         lhs, _, lhs_key_transforms = self.lhs.preprocess_lhs(compiler, connection)
         lhs_json_path = compile_json_path(lhs_key_transforms)
-    # if dealing with the JSON and not with nested structure then else block will be executed
+        lhs_params = []
     else:
+        # Otherwise, process lhs normally and set default JSON path
         lhs, lhs_params = self.process_lhs(compiler, connection)
-        lhs_json_path = "$"
+        lhs_json_path = '$'
 
     # Check if we're dealing with a Cast expression (literal JSON value)
     is_cast_expression = isinstance(self.lhs, Cast)
 
     # Process JSON paths from the right-hand side
     rhs = self.rhs
-    # rhs_params stored the complete JSON path
-    rhs_params = []
-    # Convert single values into a list for uniform processing
-    # If rhs is not already a list or tuple (i.e., it's a single key),
-    # wrap it in a list so we can handle both single and multiple keys
     if not isinstance(rhs, (list, tuple)):
+        # Ensure rhs is a list for uniform processing
         rhs = [rhs]
+
+    rhs_params = []
     for key in rhs:
-        # if dealing with the nested JSON structure then if block will be executed
         if isinstance(key, KeyTransform):
+            # If key is a KeyTransform, preprocess to get transforms
             *_, rhs_key_transforms = key.preprocess_lhs(compiler, connection)
         else:
+            # Otherwise, treat key as a single transform
             rhs_key_transforms = [key]
-        # Compile the full JSON path (lhs + rhs) according to the Django version in use
+
         if VERSION >= (4, 1):
+            # For Django 4.1+, split out the final key and build the JSON path accordingly
             *rhs_key_transforms, final_key = rhs_key_transforms
             rhs_json_path = compile_json_path(rhs_key_transforms, include_root=False)
             rhs_json_path += self.compile_json_path_final_key(final_key)
             rhs_params.append(lhs_json_path + rhs_json_path)
         else:
+            # For older Django, just compile the JSON path
             rhs_params.append(
-                "%s%s"
-                % (
+                '%s%s' % (
                     lhs_json_path,
-                    compile_json_path(rhs_key_transforms, include_root=False),
+                    compile_json_path(rhs_key_transforms, include_root=False)
                 )
             )
 
-    # For SQL Server 2022+,use JSON_PATH_EXISTS
+    # For SQL Server 2022+, use JSON_PATH_EXISTS
     if connection.sql_server_version >= 2022:
+        params = []
+        conditions = []
         if is_cast_expression:
-            # For Cast expressions, manually construct SQL without %s placeholders
+            # If lhs is a Cast, compile it to SQL and parameters
             cast_sql, cast_params = self.lhs.as_sql(compiler, connection)
 
-            # Build conditions for each key
-            conditions = []
             for path in rhs_params:
-                # Escapes single quotes in the JSON path to avoid breaking SQL syntax.
+                # Escape single quotes in the path for SQL
                 path_escaped = path.replace("'", "''")
-                # The > 0 checks that the path exists
-                conditions.append(
-                    "JSON_PATH_EXISTS(" + cast_sql + ", '" + path_escaped + "') > 0"
-                )
-            # this if else block deals with forming this syntax (JSON_PATH_EXISTS(...) > 0 AND JSON_PATH_EXISTS(...) > 0)
-            if hasattr(self, "logical_operator") and self.logical_operator:
-                logical_op = " " + self.logical_operator + " "
-                sql = "(" + logical_op.join(conditions) + ")"
-            else:
-                # if no operators are specified
-                sql = conditions[0]
+                # Build the JSON_PATH_EXISTS condition
+                conditions.append(f"JSON_PATH_EXISTS({cast_sql}, '{path_escaped}') > 0")
+            params.extend(cast_params)
 
-            return sql, cast_params
+            return _combine_conditions(conditions), params
         else:
-            conditions = []
             for path in rhs_params:
-                # Escapes single quotes in the JSON path to avoid breaking SQL syntax.
+                # Escape single quotes in the path for SQL
                 path_escaped = path.replace("'", "''")
-                conditions.append(
-                    "JSON_PATH_EXISTS(" + lhs + ", '" + path_escaped + "') > 0"
-                )
+                # Build the JSON_PATH_EXISTS condition using lhs
+                conditions.append("JSON_PATH_EXISTS(%s, '%s') > 0" % (lhs, path_escaped))
 
-            if hasattr(self, "logical_operator") and self.logical_operator:
-                logical_op = " " + self.logical_operator + " "
-                sql = "(" + logical_op.join(conditions) + ")"
-            else:
-                sql = conditions[0]
+            return _combine_conditions(conditions), lhs_params
 
-            # Return SQL with empty params list
-            return sql, []
     else:
-        # For older SQL Server versions
         if is_cast_expression:
             # SQL Server versions prior to 2022 do not support JSON_PATH_EXISTS,
             # and OPENJSON cannot be used on literal JSON values (i.e., values not stored in a table column).
@@ -409,41 +402,17 @@ def json_HasKeyLookup(self, compiler, connection):
             # we return a constant true condition ("1=1") with no parameters, which effectively returns all rows.
             return "1=1", []
         else:
-            # Handling for versions prior to SQL Server 2022
-            # For older SQL Server versions, we use OPENJSON to check for the existence of keys in JSON data.
-            if VERSION >= (4, 2):
-                try:
-                    # Get table name from compiler query for Django 4.2+
-                    # This retrieves the alias Django assigned to the main table in the SQL query.
-                    # An alias is something like "T1" or "U0" that Django uses internally in the SQL it generates.
-                    main_alias = compiler.query.get_initial_alias()
-                    # Get the table name from the alias map
-                    table_name = compiler.query.alias_map[main_alias].table_name
-                except (AttributeError, KeyError):
-                    # Fallback to traditional method
-                    table_name = self.lhs.output_field.model._meta.db_table
-            else:
-                table_name = self.lhs.output_field.model._meta.db_table
-
-            # Build SQL conditions with string concatenation 
             conditions = []
             for path in rhs_params:
-                # Escapes single quotes in the JSON path to avoid breaking SQL syntax.
-                path_escaped = path.replace("'", "''")    
-                condition = (lhs + " IN (SELECT " + lhs + " FROM " + table_name +
-                            " CROSS APPLY OPENJSON(" + lhs + ") WITH ([json_path_value] char(1) '" + 
-                            path_escaped + "') WHERE [json_path_value] IS NOT NULL)")
-                conditions.append(condition)
-
-            if hasattr(self, "logical_operator") and self.logical_operator:
-                logical_op = " " + self.logical_operator + " "
-                sql = "(" + logical_op.join(conditions) + ")"
-            else:
-                sql = conditions[0]
+                # Escape single quotes in the path for SQL
+                path_escaped = path.replace("'", "''")
+                # Build the JSON_VALUE IS NOT NULL condition
+                conditions.append("JSON_VALUE(%s, '%s') IS NOT NULL" % (lhs, path_escaped))
+
+            return _combine_conditions(conditions), lhs_params
 
-            # Return SQL with no params 
-            return sql, []
 
+        
 def BinaryField_init(self, *args, **kwargs):
     # Add max_length option for BinaryField, default to max
     kwargs.setdefault('editable', False)