support db_default

Author: psharma-1909

django_singlestore/features.py

@@ -335,7 +335,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_unlimited_charfield = False
 
     # Does the backend support database-side default values?
-    supports_db_default = False
+    supports_db_default = True
 
     supports_update_conflicts_with_target = False
 
@@ -878,6 +878,9 @@ def django_test_expected_failures(self):
             # Auto increment fields must have BIGINT data type . default is BigAutoField
             "introspection.tests.IntrospectionTests.test_get_table_description_types",
             "introspection.tests.IntrospectionTests.test_smallautofield",
+            # db_default parameter does no support complex functions.
+            "field_defaults.tests.DefaultTests.test_case_when_db_default_no_returning",
+            "migrations.test_operations.OperationTests.test_add_field_database_default_function",
         }
 
         return fails

django_singlestore/schema.py

@@ -3,6 +3,7 @@
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.models import Manager
 from django.db.models import NOT_PROVIDED
+from django.db.models.sql import Query
 
 
 class ModelStorageManager(Manager):
@@ -67,6 +68,25 @@ def quote_value(self, value):
     def prepare_default(self, value):
         return self.quote_value(value)
 
+    def db_default_sql(self, field):
+        """Return the sql and params for the field's database default."""
+        from django.db.models.expressions import Value
+
+        db_default = field._db_default_expression
+        sql = (
+            self._column_default_sql(field) if isinstance(db_default, Value) else "%s"
+        )
+        query = Query(model=field.model)
+        compiler = query.get_compiler(connection=self.connection)
+        default_sql, params = compiler.compile(db_default)
+        if self.connection.features.requires_literal_defaults:
+            # Some databases don't support parameterized defaults (Oracle,
+            # SQLite). If this is the case, the individual schema backend
+            # should implement prepare_default().
+            default_sql %= tuple(self.prepare_default(p) for p in params)
+            params = []
+        return sql % default_sql, params
+
     def column_sql(self, model, field, include_default=False):
         """
         Return the column definition for a field. The field must already have
@@ -85,9 +105,30 @@ def column_sql(self, model, field, include_default=False):
             result_sql_parts.append(self._collate_sql(collation))
         if self.connection.features.supports_comments_inline and field.db_comment:
             result_sql_parts.append(self._comment_sql(field.db_comment))
-        # Include a default value, if requested.
-        include_default = include_default and not field.null
-        if include_default:
+
+        # Handle db_default (database-level default)
+        if hasattr(field, 'db_default') and field.db_default is not NOT_PROVIDED:
+            # db_default takes precedence over regular default when creating columns
+            default_sql, default_params = self.db_default_sql(field)
+            result_sql_parts.append("DEFAULT " + default_sql)
+            params.extend(default_params)
+            # if hasattr(field.db_default, 'resolve_expression'):
+            #     # It's a database function (like Now())
+            #     compiler = self.connection.ops.compiler('SQLCompiler')(
+            #         query=None, connection=self.connection, using=None
+            #     )
+            #     db_default_sql = field.db_default.as_sql(compiler, self.connection)[0]
+            #     result_sql_parts.append("DEFAULT " + db_default_sql)
+            # else:
+            #     # It's a literal value
+            #     db_default_sql = self._column_default_sql(field)
+            #     if self.connection.features.requires_literal_defaults:
+            #         result_sql_parts.append("DEFAULT " + db_default_sql % self.prepare_default(field.db_default))
+            #     else:
+            #         result_sql_parts.append("DEFAULT " + db_default_sql)
+            #         params.append(field.db_default)
+        # Include a regular default value, if requested and no db_default is set.
+        elif include_default and not field.null:
             default_value = self.effective_default(field)
             if default_value is not None:
                 column_default = "DEFAULT " + self._column_default_sql(field)
@@ -221,8 +262,19 @@ def add_field(self, model, field):
         super().add_field(model, field)
 
         # Simulate the effect of a one-off default.
+        if hasattr(field, 'db_default') and field.db_default is not NOT_PROVIDED:
+            default_sql, default_params = self.db_default_sql(field)
+            self.execute(
+                "UPDATE %(table)s SET %(column)s = %(default_value)s"
+                % {
+                    "table": self.quote_name(model._meta.db_table),
+                    "column": self.quote_name(field.column),
+                    "default_value": default_sql,
+                },
+                default_params,
+            )
         # field.default may be unhashable, so a set isn't used for "in" check.
-        if field.default not in (None, NOT_PROVIDED):
+        elif field.default not in (None, NOT_PROVIDED):
             effective_default = self.effective_default(field)
             self.execute(
                 "UPDATE %(table)s SET %(column)s = %%s"
@@ -271,3 +323,33 @@ def _alter_column_type_sql(
         return super()._alter_column_type_sql(
             model, old_field, new_field, new_type, old_collation, new_collation,
         )
+
+    def _alter_column_null_sql(self, model, old_field, new_field):
+        if new_field.db_default is NOT_PROVIDED:
+            return super()._alter_column_null_sql(model, old_field, new_field)
+
+        new_db_params = new_field.db_parameters(connection=self.connection)
+        type_sql = self._set_field_new_type(new_field, new_db_params["type"])
+        return (
+            "MODIFY %(column)s %(type)s"
+            % {
+                "column": self.quote_name(new_field.column),
+                "type": type_sql,
+            },
+            [],
+        )
+
+    def _set_field_new_type(self, field, new_type):
+        """
+        Keep the NULL and DEFAULT properties of the old field. If it has
+        changed, it will be handled separately.
+        """
+        if field.db_default is not NOT_PROVIDED:
+            default_sql, params = self.db_default_sql(field)
+            default_sql %= tuple(self.quote_value(p) for p in params)
+            new_type += f" DEFAULT {default_sql}"
+        if field.null:
+            new_type += " NULL"
+        else:
+            new_type += " NOT NULL"
+        return new_type

scripts/get_test_matrix.py

@@ -8,7 +8,7 @@
 def get_test_modules(tests_root):
     subdirs_to_skip = {
         "import_error_package", "test_runner_apps", "__pycache__", "requirements",
-        "gis_tests", "postgres_tests", "distinct_on_fields", "templates", "field_defaults",
+        "gis_tests", "postgres_tests", "distinct_on_fields", "templates",
     }
     test_modules = []
     for item in os.listdir(tests_root):