Fixed #373 -- Added CompositeField-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 E042).
+        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(
@@ -1962,6 +1970,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

@@ -47,7 +47,7 @@
     pre_init,
     pre_save,
 )
-from django.db.models.utils import AltersData, make_model_tuple
+from django.db.models.utils import AltersData, is_pk_set, make_model_tuple
 from django.utils.deprecation import RemovedInDjango60Warning
 from django.utils.encoding import force_str
 from django.utils.hashable import make_hashable
@@ -1076,7 +1076,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 = is_pk_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
@@ -1682,6 +1682,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
@@ -1690,6 +1691,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.
@@ -1718,6 +1722,24 @@ def _check_default_pk(cls):
             ]
         return []
 
+    @classmethod
+    def _check_composite_pk(cls):
+        errors = []
+
+        if cls._meta.primary_key and any(
+            field for field in cls._meta.fields if field.primary_key
+        ):
+            errors.append(
+                checks.Error(
+                    "primary_key=True must not be set if Meta.primary_key "
+                    "is defined.",
+                    obj=cls,
+                    id="models.E042",
+                )
+            )
+
+        return errors
+
     @classmethod
     def _check_db_table_comment(cls, databases):
         if not cls._meta.db_table_comment:
@@ -1838,6 +1860,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/deletion.py

@@ -514,5 +514,12 @@ def delete(self):
 
         for model, instances in self.data.items():
             for instance in instances:
-                setattr(instance, model._meta.pk.attname, None)
+                try:
+                    fields = iter(model._meta.pk)
+                except TypeError:
+                    fields = (model._meta.pk,)
+
+                for field in fields:
+                    setattr(instance, field.attname, None)
+
         return sum(deleted_counter.values()), dict(deleted_counter)

django/db/models/fields/__init__.py

@@ -2794,6 +2794,11 @@ def check(self, **kwargs):
         ]
 
     def _check_primary_key(self):
+        # If the model defines Meta.primary_key, primary_key=True can't be set on
+        # any field (including AutoFields).
+        if self.model._meta.primary_key:
+            return []
+
         if not self.primary_key:
             return [
                 checks.Error(
@@ -2808,7 +2813,7 @@ def _check_primary_key(self):
     def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
         del kwargs["blank"]
-        kwargs["primary_key"] = True
+        kwargs["primary_key"] = self.primary_key
         return name, path, args, kwargs
 
     def validate(self, value, model_instance):

django/db/models/fields/composite.py

@@ -0,0 +1,81 @@
+from django.db.models import Field
+from django.db.models.expressions import Col, Expression
+from django.db.models.lookups import TupleExact, TupleIn
+from django.db.models.signals import class_prepared
+from django.utils.functional import cached_property
+
+
+class Cols(Expression):
+    def __init__(self, alias, targets, output_field):
+        super().__init__(output_field=output_field)
+        self.alias, self.targets = alias, 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)
+        assert len(exprs) == len(self.targets)
+
+    def __iter__(self):
+        return iter(self.get_source_expressions())
+
+
+class CompositeAttribute:
+    def __init__(self, field):
+        self.field = field
+
+    def __get__(self, instance, cls=None):
+        return tuple(
+            getattr(instance, field_name) for field_name in self.field.field_names
+        )
+
+    def __set__(self, instance, values):
+        for field_name, value in zip(self.field.field_names, values):
+            setattr(instance, field_name, value)
+
+
+class CompositeField(Field):
+    descriptor_class = CompositeAttribute
+
+    def __init__(self, *args, **kwargs):
+        kwargs["db_column"] = None
+        kwargs["editable"] = False
+        super().__init__(**kwargs)
+        self.field_names = args
+        self.fields = None
+
+    def contribute_to_class(self, cls, name, private_only=False):
+        super().contribute_to_class(cls, name, private_only)
+        cls._meta.pk = self
+        setattr(cls, self.attname, self.descriptor_class(self))
+
+    def get_attname_column(self):
+        return self.get_attname(), self.db_column
+
+    def __iter__(self):
+        return iter(self.fields)
+
+    @cached_property
+    def cached_col(self):
+        return Cols(self.model._meta.db_table, self.fields, self)
+
+    def get_lookup(self, lookup_name):
+        if lookup_name == "exact":
+            return TupleExact
+        elif lookup_name == "in":
+            return TupleIn
+
+        return super().get_lookup(lookup_name)
+
+
+def resolve_columns(*args, **kwargs):
+    cls = kwargs.pop("sender")
+    for field in cls._meta.local_fields:
+        if isinstance(field, CompositeField) and field.fields is None:
+            field.fields = tuple(
+                cls._meta.get_field(name) for name in field.field_names
+            )
+
+
+class_prepared.connect(resolve_columns)

django/db/models/fields/related.py

@@ -615,6 +615,16 @@ def _check_unique_target(self):
         if not self.foreign_related_fields:
             return []
 
+        # If a model defines Meta.primary_key and a foreign key refers to it,
+        # the check should be skipped (since primary keys are unique).
+        pk = self.remote_field.model._meta.primary_key
+        if pk:
+            pk = set(pk)
+            if pk == {f.attname for f in self.foreign_related_fields}:
+                return []
+            elif pk == {f.name for f in self.foreign_related_fields}:
+                return []
+
         has_unique_constraint = any(
             rel_field.unique for rel_field in self.foreign_related_fields
         )

django/db/models/lookups.py

@@ -385,6 +385,18 @@ def as_sql(self, compiler, connection):
         return super().as_sql(compiler, connection)
 
 
+class TupleExact(Exact):
+    def as_sql(self, compiler, connection):
+        from django.db.models.sql.where import AND, WhereNode
+
+        exprs = [
+            Exact(lhs, rhs)
+            for lhs, rhs in zip(self.lhs.get_source_expressions(), self.rhs)
+        ]
+
+        return compiler.compile(WhereNode(exprs, connector=AND))
+
+
 @Field.register_lookup
 class IExact(BuiltinLookup):
     lookup_name = "iexact"
@@ -558,6 +570,39 @@ def split_parameter_list_as_sql(self, compiler, connection):
         return "".join(in_clause_elements), params
 
 
+class TupleIn(In):
+    def get_prep_lookup(self):
+        try:
+            lhs = list(self.lhs)
+        except TypeError:
+            raise ValueError(f"lhs={self.lhs} is not iterable")
+        try:
+            rhs = list(self.rhs)
+        except TypeError:
+            raise ValueError(f"rhs={self.rhs} is not iterable")
+
+        if not all(len(values) == len(lhs) for values in rhs):
+            raise ValueError(f"rhs={rhs} must match lhs={lhs}")
+
+        return super().get_prep_lookup()
+
+    def as_sql(self, compiler, connection):
+        from django.db.models.sql.where import AND, OR, WhereNode
+
+        exprs = []
+        lhs = self.lhs.get_source_expressions()
+
+        for rhs in self.rhs:
+            exprs.append(
+                WhereNode(
+                    [Exact(col, value) for col, value in zip(lhs, rhs)],
+                    connector=AND,
+                )
+            )
+
+        return compiler.compile(WhereNode(exprs, connector=OR))
+
+
 class PatternLookup(BuiltinLookup):
     param_pattern = "%%%s%%"
     prepare_rhs = False

django/db/models/options.py

@@ -7,6 +7,7 @@
 from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured
 from django.db import connections
 from django.db.models import AutoField, Manager, OrderWrt, UniqueConstraint
+from django.db.models.fields.composite import CompositeField
 from django.db.models.query_utils import PathInfo
 from django.utils.datastructures import ImmutableList, OrderedSet
 from django.utils.functional import cached_property
@@ -24,6 +25,7 @@
 )
 
 DEFAULT_NAMES = (
+    "primary_key",
     "verbose_name",
     "verbose_name_plural",
     "db_table",
@@ -106,6 +108,7 @@ def __init__(self, meta, app_label=None):
         self.base_manager_name = None
         self.default_manager_name = None
         self.model_name = None
+        self.primary_key = None
         self.verbose_name = None
         self.verbose_name_plural = None
         self.db_table = ""
@@ -296,7 +299,10 @@ def _prepare(self, model):
             self.order_with_respect_to = None
 
         if self.pk is None:
-            if self.parents:
+            if self.primary_key:
+                pk = CompositeField(*self.primary_key)
+                model.add_to_class("composite_pk", pk)
+            elif self.parents:
                 # Promote the first parent link in lieu of adding yet another
                 # field.
                 field = next(iter(self.parents.values()))

django/db/models/query.py

@@ -30,6 +30,7 @@
 from django.db.models.utils import (
     AltersData,
     create_namedtuple_class,
+    is_pk_set,
     resolve_callables,
 )
 from django.utils import timezone
@@ -813,7 +814,9 @@ def bulk_create(
         objs = list(objs)
         self._prepare_for_bulk_create(objs)
         with transaction.atomic(using=self.db, savepoint=False):
-            objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
+            objs_with_pk, objs_without_pk = partition(
+                lambda o: not is_pk_set(o.pk), objs
+            )
             if objs_with_pk:
                 returned_columns = self._batched_insert(
                     objs_with_pk,

django/db/models/utils.py

@@ -1,5 +1,6 @@
 import functools
 from collections import namedtuple
+from collections.abc import Iterable
 
 
 def make_model_tuple(model):
@@ -67,3 +68,22 @@ def __init_subclass__(cls, **kwargs):
                         break
 
         super().__init_subclass__(**kwargs)
+
+
+def is_pk_set(pk):
+    """
+    >>> is_pk_set(1)
+    True
+    >>> is_pk_set(None)
+    False
+    >>> is_pk_set((1, 1))
+    True
+    >>> is_pk_set((1, None))
+    False
+    """
+    if pk is None:
+        return False
+    if isinstance(pk, Iterable):
+        return not any(value is None for value in pk)
+
+    return True

docs/ref/checks.txt

@@ -416,6 +416,8 @@ Models
 * **models.W040**: ``<database>`` does not support indexes with non-key
   columns.
 * **models.E041**: ``constraints`` refers to the joined field ``<field name>``.
+* **models.E042**: primary_key=True must not be set if Meta.primary_key
+  is defined.
 * **models.W042**: Auto-created primary key used when not defining a primary
   key type, by default ``django.db.models.AutoField``.
 * **models.W043**: ``<database>`` does not support indexes on expressions.