Fixed #373 -- Added CompositePrimaryKey-based Meta.primary_key.

django/db/backends/base/schema.py

@@ -105,6 +105,7 @@ class BaseDatabaseSchemaEditor:
     sql_check_constraint = "CHECK (%(check)s)"
     sql_delete_constraint = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s"
     sql_constraint = "CONSTRAINT %(name)s %(constraint)s"
+    sql_pk_constraint = "PRIMARY KEY (%(columns)s)"
 
     sql_create_check = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s CHECK (%(check)s)"
     sql_delete_check = sql_delete_constraint
@@ -268,6 +269,13 @@ def table_sql(self, model):
             constraint.constraint_sql(model, self)
             for constraint in model._meta.constraints
         ]
+
+        # If the model defines Meta.primary_key, add the primary key constraint
+        # to the table definition.
+        # It's expected primary_key=True isn't set on any fields (see E043).
+        if model._meta.primary_key:
+            constraints.append(self._pk_constraint_sql(model._meta.primary_key))
+
         sql = self.sql_create_table % {
             "table": self.quote_name(model._meta.db_table),
             "definition": ", ".join(
@@ -1967,6 +1975,11 @@ def _constraint_names(
                     result.append(name)
         return result
 
+    def _pk_constraint_sql(self, fields):
+        return self.sql_pk_constraint % {
+            "columns": ", ".join(self.quote_name(field) for field in fields)
+        }
+
     def _delete_primary_key(self, model, strict=False):
         constraint_names = self._constraint_names(model, primary_key=True)
         if strict and len(constraint_names) != 1:

django/db/models/base.py

@@ -1080,7 +1080,7 @@ def _save_table(
         if pk_val is None:
             pk_val = meta.pk.get_pk_value_on_save(self)
             setattr(self, meta.pk.attname, pk_val)
-        pk_set = pk_val is not None
+        pk_set = meta.pk.is_set(pk_val)
         if not pk_set and (force_update or update_fields):
             raise ValueError("Cannot force an update in save() with no primary key.")
         updated = False
@@ -1369,10 +1369,12 @@ def _get_unique_checks(self, exclude=None, include_meta_constraints=False):
         """
         if exclude is None:
             exclude = set()
-        unique_checks = []
 
+        unique_checks = []
         unique_togethers = [(self.__class__, self._meta.unique_together)]
         constraints = []
+        pk_fields = self._meta.pk_fields
+
         if include_meta_constraints:
             constraints = [(self.__class__, self._meta.total_unique_constraints)]
         for parent_class in self._meta.all_parents:
@@ -1385,6 +1387,16 @@ def _get_unique_checks(self, exclude=None, include_meta_constraints=False):
                     (parent_class, parent_class._meta.total_unique_constraints)
                 )
 
+        if (
+            self._meta.primary_key
+            and "primary_key" not in exclude
+            and "pk" not in exclude
+            and not any(field.name in exclude for field in pk_fields)
+        ):
+            unique_checks.append(
+                (self.__class__, tuple(field.name for field in pk_fields))
+            )
+
         for model_class, unique_together in unique_togethers:
             for check in unique_together:
                 if not any(name in exclude for name in check):
@@ -1420,6 +1432,7 @@ def _get_unique_checks(self, exclude=None, include_meta_constraints=False):
                     date_checks.append((model_class, "year", name, f.unique_for_year))
                 if f.unique_for_month and f.unique_for_month not in exclude:
                     date_checks.append((model_class, "month", name, f.unique_for_month))
+
         return unique_checks, date_checks
 
     def _perform_unique_checks(self, unique_checks):
@@ -1686,6 +1699,7 @@ def check(cls, **kwargs):
                 *cls._check_constraints(databases),
                 *cls._check_default_pk(),
                 *cls._check_db_table_comment(databases),
+                *cls._check_composite_pk(),
             ]
 
         return errors
@@ -1694,6 +1708,9 @@ def check(cls, **kwargs):
     def _check_default_pk(cls):
         if (
             not cls._meta.abstract
+            # If the model defines Meta.primary_key, the check should be skipped,
+            # since there's no default primary key.
+            and not cls._meta.primary_key
             and cls._meta.pk.auto_created
             and
             # Inherited PKs are checked in parents models.
@@ -1722,6 +1739,52 @@ def _check_default_pk(cls):
             ]
         return []
 
+    @classmethod
+    def _check_composite_pk(cls):
+        errors = []
+        meta = cls._meta
+
+        if meta.primary_key is None:
+            return errors
+
+        for field in meta.fields:
+            if field.primary_key:
+                errors.append(
+                    checks.Error(
+                        "'%s' may not set 'primary_key=True' if 'Meta.primary_key' "
+                        "is defined." % (field.name,),
+                        obj=cls,
+                        id="models.E042",
+                    )
+                )
+
+        fields_map = {field.attname: field for field in meta.concrete_fields}
+
+        for field_name in meta.primary_key:
+            field = fields_map.get(field_name)
+            if not field:
+                errors.append(
+                    checks.Error(
+                        "'%s' cannot be included in 'Meta.primary_key'."
+                        % (field_name,),
+                        hint="'%s' is not an existing, concrete field." % (field_name,),
+                        obj=cls,
+                        id="models.E043",
+                    )
+                )
+            elif field.null:
+                errors.append(
+                    checks.Error(
+                        "'%s' cannot be included in 'Meta.primary_key'."
+                        % (field.name,),
+                        hint="'%s' may not set 'null=True'." % (field.name,),
+                        obj=cls,
+                        id="models.E043",
+                    )
+                )
+
+        return errors
+
     @classmethod
     def _check_db_table_comment(cls, databases):
         if not cls._meta.db_table_comment:
@@ -1842,6 +1905,11 @@ def _check_m2m_through_same_relationship(cls):
     @classmethod
     def _check_id_field(cls):
         """Check if `id` field is a primary key."""
+        # If the model defines Meta.primary_key, the check should be skipped,
+        # since primary_key=True can't be set on any fields (including `id`).
+        if cls._meta.primary_key:
+            return []
+
         fields = [
             f for f in cls._meta.local_fields if f.name == "id" and f != cls._meta.pk
         ]

django/db/models/expressions.py

@@ -1274,6 +1274,34 @@ def get_db_converters(self, connection):
         ) + self.target.get_db_converters(connection)
 
 
+class Cols(Expression):
+    def __init__(self, alias, targets, output_field):
+        super().__init__(output_field=output_field)
+        self.targets, self.alias = targets, alias
+
+    def __len__(self):
+        return len(self.targets)
+
+    def get_source_expressions(self):
+        return [Col(self.alias, target) for target in self.targets]
+
+    def set_source_expressions(self, exprs):
+        assert all(isinstance(expr, Col) for expr in exprs)
+        self.targets = [col.target for col in exprs]
+
+    def as_sql(self, compiler, connection):
+        cols_sql = []
+        cols_params = []
+        cols = self.get_source_expressions()
+
+        for col in cols:
+            sql, params = col.as_sql(compiler, connection)
+            cols_sql.append(sql)
+            cols_params.extend(params)
+
+        return ", ".join(cols_sql), cols_params
+
+
 class Ref(Expression):
     """
     Reference to column alias of the query. For example, Ref('sum_cost') in

django/db/models/fields/__init__.py

@@ -1153,6 +1153,10 @@ def slice_expression(self, expression, start, length):
         """Return a slice of this field."""
         raise NotSupportedError("This field does not support slicing.")
 
+    @classmethod
+    def is_set(cls, value):
+        return value is not None
+
 
 class BooleanField(Field):
     empty_strings_allowed = False