Django BigInteger autoincremento de campo como clave principal?

Question

Actualmente estoy construyendo un proyecto que involucra mucha inteligencia colectiva. Cada usuario que visita el sitio web se crea un perfil único y sus datos se utilizan luego para calcular las mejores coincidencias para ellos y otros usuarios.

De forma predeterminada, Django crea un campo INT (11) id para manejar las claves primarias de los modelos. Me preocupa que esto se desborde muy rápidamente (es decir, ~ 2.4b dispositivos que visitan la página sin configuración previa de cookies). ¿Cómo puedo cambiarlo para que se represente como BIGINT en MySQL y long() dentro de Django?

he encontrado lo que podía hacer lo siguiente (http://docs.djangoproject.com/en/dev/ref/models/fields/#bigintegerfield):

class MyProfile(models.Model): 
    id = BigIntegerField(primary_key=True) 

Pero hay una manera para que sea incrementado automáticamente, como de costumbre id campos? Además, ¿puedo hacerlo sin firmar para que tenga más espacio para completar?

Gracias!

Answer 1

Django tiene ahora un BigAutoField construido en si está usando Django 1.10:

https://docs.djangoproject.com/en/1.10/ref/models/fields/#bigautofield

Answer 2

Puede cambiar la tabla posteriormente. Esa puede ser una mejor solución.

Answer 3

También tuve el mismo problema. Parece que no hay soporte para los campos automáticos BigInteger en django.

He intentado crear un campo personalizado BigIntegerAutoField pero tuve un problema con el sistema de migración al sur (South no pudo crear una secuencia para mi campo).

Después de dar un par intento de los diferentes enfoques que decidí seguir el consejo de Mateo y alteran la tabla (por ejemplo ALTER TABLE table_name ALTER COLUMN id TYPE bigint; en PostgreSQL)

sería bueno tener solución con el apoyo de Django (como construida en BigIntegerAutoField) y el sur.

Answer 4

NOTA: Esta respuesta se modificó según el código de Larry. Solución hasta ahora extendida fields.BigIntegerField, pero mejor extender fields.AutoField

que tenía el mismo problema y resuelto con la siguiente código:

from django.db.models import fields 
from south.modelsinspector import add_introspection_rules 

class BigAutoField(fields.AutoField): 
    def db_type(self, connection): 
     if 'mysql' in connection.__class__.__module__: 
      return 'bigint AUTO_INCREMENT' 
     return super(BigAutoField, self).db_type(connection) 

add_introspection_rules([], ["^MYAPP\.fields\.BigAutoField"]) 

Al parecer, este está trabajando muy bien con las migraciones al sur.

Answer 5

Como se indicó anteriormente, podría modificar la tabla posteriormente. Esa es una buena solución.

Para hacer eso sin olvidar, puede crear un módulo de gestión en su paquete de aplicación y usar la señal post_syncdb.

https://docs.djangoproject.com/en/dev/ref/signals/#post-syncdb

Esto puede causar rubor django-admin.py falle. Pero sigue siendo la mejor alternativa que conozco.

Answer 6

Inspirado por lfagundes pero con una pequeña pero importante corrección:

class BigAutoField(fields.AutoField): 
    def db_type(self, connection): # pylint: disable=W0621 
     if 'mysql' in connection.__class__.__module__: 
      return 'bigint AUTO_INCREMENT' 
     return super(BigAutoField, self).db_type(connection) 

add_introspection_rules([], [r"^a\.b\.c\.BigAutoField"]) 

Aviso en lugar de extender BigIntegerField, les extiendo AutoField. Esta es una distinción importante. Con AutoField, Django recuperará el ID AUTO INCREMENTADO de la base de datos, mientras que BigInteger no lo hará.

Una preocupación al cambiar de BigIntegerField a AutoField fue la conversión de los datos a un int en AutoField.

Aviso de AutoField de Django:

def to_python(self, value): 
    if value is None: 
     return value 
    try: 
     return int(value) 
    except (TypeError, ValueError): 
     msg = self.error_messages['invalid'] % str(value) 
     raise exceptions.ValidationError(msg) 

y

def get_prep_value(self, value): 
    if value is None: 
     return None 
    return int(value) 

Resulta que esto está bien, como se verifica en una cáscara de pitón:

>>> l2 = 99999999999999999999999999999 
>>> type(l2) 
<type 'long'> 
>>> int(l2) 
99999999999999999999999999999L 
>>> type(l2) 
<type 'long'> 
>>> type(int(l2)) 
<type 'long'> 

En otras palabras, de fundición a un int no truncará el número, ni cambiará el tipo subyacente.