Merge branch 'dev' into Nandana/5.2/composite-primary-key

Author: bewithgaurav

.github/workflows/codeql-analysis.yml

@@ -11,6 +11,12 @@
 #
 name: "CodeQL"
 
+# This workflow is triggered on pushes to the dev branch, pull requests targeting
+permissions:
+  actions: read
+  contents: read
+  security-events: write
+
 on:
   push:
     branches: [ dev ]

README.md

@@ -10,9 +10,13 @@ We hope you enjoy using the MSSQL-Django 3rd party backend.
 
 ## Features
 
--  Supports Django 3.2, 4.0, 4.1, 4.2 and 5.0
+-  Supports Django 3.2, 4.0, 4.1, 4.2, 5.0, 5.1, and 5.2
+   - **Django 5.0 and below**: Full production support
+   - **Django 5.1**: Supported with minor limitations (composite primary key inspectdb)
+   - **Django 5.2**: Supported with enhanced SQL Server compatibility features and documented limitations (see Django 5.2 Specific Limitations section below)
 -  Tested on Microsoft SQL Server 2016, 2017, 2019, 2022
 -  Passes most of the tests of the Django test suite
+-  Enhanced SQL Server compatibility with automatic schema creation and improved identifier quoting
 -  Compatible with
    [Micosoft ODBC Driver for SQL Server](https://docs.microsoft.com/en-us/sql/connect/odbc/microsoft-odbc-driver-for-sql-server),
    [SQL Server Native Client](https://msdn.microsoft.com/en-us/library/ms131321(v=sql.120).aspx),
@@ -273,6 +277,42 @@ The following features are currently not fully supported:
 - Date extract function
 - Bulk insert into a table with a trigger and returning the rows inserted
 
+### Django 5.1 Specific Limitations
+
+Django 5.1 introduces composite primary key support which has limited compatibility with SQL Server:
+- **inspectdb command**: Cannot properly inspect tables with composite primary keys
+- **Backend debugging**: SQL execution wrapper debug functionality may not work correctly
+- **Schema operations**: Some field unique constraint removal operations may have issues
+- Most other Django 5.1 features work correctly with SQL Server
+
+### Django 5.2 Specific Limitations
+
+Django 5.2 introduces new features that may cause regressions for existing Django 5.0+ applications. This release includes enhanced SQL Server compatibility for Django 5.2, with automatic schema creation and improved identifier quoting. The following limitations remain:
+
+**Critical Limitations (May Affect Common Use Cases):**
+- **Tuple lookups**: Queries like `Model.objects.filter((col1, col2)__in=[(val1, val2)])` will fail with SQL syntax errors as SQL Server doesn't support `(col1, col2) IN (...)` syntax
+- **Multi-column foreign key relationships**: Complex queries involving foreign keys with multiple columns may fail in Django 5.2 due to tuple lookup generation
+- **JSONField with special characters**: JSONField lookups involving special characters (quotes, emojis, escape sequences) may generate invalid SQL
+- **JSONField bulk updates**: Bulk update operations on JSONField with null handling may fail
+
+**Moderate Impact:**
+- **Complex aggregations**: Some aggregation queries with filtered references and subqueries may not work correctly
+- **Prefetch operations**: `prefetch_related()` operations on multi-column foreign keys may fail
+
+**Low Impact (Edge Cases):**
+- **Migration operations**: Advanced migration operations involving composite primary keys and generated fields
+- **Backend debugging**: Certain backend debugging and introspection features
+- **JSONField CASE WHEN updates**: JSONField updates using CASE WHEN expressions with null handling
+
+**Specific Test Failures in Django 5.2:**
+- All `foreign_object.test_tuple_lookups.TupleLookupsTests.*` tests
+- All `foreign_object.tests.MultiColumnFKTests.*` tests involving complex queries
+- `model_fields.test_jsonfield.TestQuerying.test_lookups_special_chars*` tests
+- `queries.test_bulk_update.BulkUpdateTests.test_json_field_sql_null` test
+- Various migration and backend debugging tests
+
+**Workaround**: These limitations are documented in the test exclusions (`testapp/settings.py`) and are excellent candidates for community contributions. Applications using Django 5.0 and below are unaffected by these limitations.
+
 JSONField lookups have limitations, more details [here](https://github.com/microsoft/mssql-django/wiki/JSONField).
 
 ## Contributing

azure-pipelines.yml

@@ -176,7 +176,7 @@ jobs:
         Python3.10 - Django 5.2:
           python.version: '3.10'
           tox.env: 'py310-django52'
-          
+
         Python3.13 - Django 5.1:
           python.version: '3.13'
           tox.env: 'py313-django51'

mssql/creation.py

@@ -27,7 +27,13 @@ def _create_test_db(self, verbosity, autoclobber, keepdb=False):
         #   so we can proceed if we're keeping the DB anyway.
         # https://github.com/microsoft/mssql-django/issues/61
         try:
-            return super()._create_test_db(verbosity, autoclobber, keepdb)
+            test_database_name = super()._create_test_db(verbosity, autoclobber, keepdb)
+            
+            # Create required schemas for Django tests (only for 5.2+)
+            if django_version >= (5, 2):
+                self._create_test_schemas(test_database_name, verbosity)
+
+            return test_database_name
         except InterfaceError as err:
             if err.args[0] == '28000' and keepdb:
                 self.log('Received error %s, proceeding because keepdb=True' % (
@@ -36,6 +42,32 @@ def _create_test_db(self, verbosity, autoclobber, keepdb=False):
             else:
                 raise err
 
+    def _create_test_schemas(self, test_database_name, verbosity):
+        """
+        Create required schemas in test database for Django tests.
+        """
+        schemas_to_create = ['inspectdb_special', 'inspectdb_pascal']
+        
+        # Use a cursor connected to the test database
+        test_settings = self.connection.settings_dict.copy()
+        test_settings['NAME'] = test_database_name
+        test_connection = self.connection.__class__(test_settings)
+        
+        try:
+            with test_connection.cursor() as cursor:
+                for schema in schemas_to_create:
+                    try:
+                        quoted_schema = self.connection.ops.quote_name(schema)
+                        cursor.execute(f"CREATE SCHEMA {quoted_schema}")
+                        if verbosity >= 2:
+                            self.log(f'Created schema {schema} in test database {test_database_name}')
+                    except Exception as e:
+                        # Schema might already exist, which is fine
+                        if verbosity >= 2:
+                            self.log(f'Schema {schema} creation failed (might already exist): {e}')
+        finally:
+            test_connection.close()
+
     def _destroy_test_db(self, test_database_name, verbosity):
         """
         Internal implementation - remove the test db tables.