In Django - Model Inheritance - Ti consente di sovrascrivere l'attributo di un modello genitore?

Sto cercando di fare questo:

class Place(models.Model):
   name = models.CharField(max_length=20)
   rating = models.DecimalField()

class LongNamedRestaurant(Place):  # Subclassing `Place`.
   name = models.CharField(max_length=255)  # Notice, I'm overriding `Place.name` to give it a longer length.
   food_type = models.CharField(max_length=25)

Questa è la versione che vorrei usare (anche se sono aperto a qualsiasi suggerimento): http://docs.djangoproject.com/en/dev/topics/db/models/#id7

È supportato in Django? In caso contrario, esiste un modo per ottenere risultati simili?

Risposta aggiornata: come le persone hanno notato nei commenti, la risposta originale non rispondeva correttamente alla domanda. In effetti, solo il LongNamedRestaurantmodello è stato creato nel database, Placenon lo era.

Una soluzione è creare un modello astratto che rappresenti un "Luogo", ad es. AbstractPlace, ed eredita da esso:

class AbstractPlace(models.Model):
    name = models.CharField(max_length=20)
    rating = models.DecimalField()

    class Meta:
        abstract = True

class Place(AbstractPlace):
    pass

class LongNamedRestaurant(AbstractPlace):
    name = models.CharField(max_length=255)
    food_type = models.CharField(max_length=25)

Si prega di leggere anche la risposta di @Mark , fornisce un'ottima spiegazione del perché non è possibile modificare gli attributi ereditati da una classe non astratta.

(Nota questo è possibile solo da Django 1.10: prima di Django 1.10, non era possibile modificare un attributo ereditato da una classe astratta.)

Risposta originale

Da Django 1.10 è possibile ! Devi solo fare quello che hai chiesto:

class Place(models.Model):
    name = models.CharField(max_length=20)
    rating = models.DecimalField()

    class Meta:
        abstract = True

class LongNamedRestaurant(Place):  # Subclassing `Place`.
    name = models.CharField(max_length=255)  # Notice, I'm overriding `Place.name` to give it a longer length.
    food_type = models.CharField(max_length=25)

No, non è :

Il nome del campo "nascondere" non è consentito

Nella normale ereditarietà delle classi Python, è consentito a una classe figlia sovrascrivere qualsiasi attributo della classe genitore. In Django, questo non è consentito per attributi che sono Fieldistanze (almeno, non al momento). Se una classe base ha un campo chiamato author, non è possibile creare un altro campo modello chiamato authorin nessuna classe che eredita da quella classe base.

Ciò non è possibile a meno che non sia astratto, ed ecco perché: LongNamedRestaurantè anche a Place, non solo come classe ma anche nel database. Il tavolo del posto contiene una voce per ogni puro Placee per ogni LongNamedRestaurant. LongNamedRestaurantcrea solo una tabella aggiuntiva con food_typee un riferimento alla tabella del luogo.

Se lo fai Place.objects.all(), ottieni anche ogni luogo che è a LongNamedRestaurant, e sarà un'istanza di Place(senza food_type). Quindi Place.namee LongNamedRestaurant.namecondividono la stessa colonna del database e devono quindi essere dello stesso tipo.

Penso che questo abbia senso per i modelli normali: ogni ristorante è un posto e dovrebbe avere almeno tutto ciò che quel posto ha. Forse questa coerenza è anche il motivo per cui non era possibile per i modelli astratti prima della 1.10, anche se lì non avrebbe dato problemi al database. Come osserva @lampslave, è stato reso possibile in 1.10. Consiglierei personalmente attenzione: se Sub.x sostituisce Super.x, assicurati che Sub.x sia una sottoclasse di Super.x, altrimenti Sub non può essere usato al posto di Super.

Soluzioni alternative : è possibile creare un modello utente personalizzato ( AUTH_USER_MODEL) che comporta una discreta duplicazione del codice se è necessario modificare solo il campo dell'email. In alternativa puoi lasciare l'email così com'è e assicurarti che sia richiesta in tutte le forme. Ciò non garantisce l'integrità del database se viene utilizzato da altre applicazioni e non funziona viceversa (se si desidera rendere il nome utente non richiesto).

Vedi https://stackoverflow.com/a/6379556/15690 :

class BaseMessage(models.Model):
    is_public = models.BooleanField(default=False)
    # some more fields...

    class Meta:
        abstract = True

class Message(BaseMessage):
    # some fields...
Message._meta.get_field('is_public').default = True

Incollato il codice in una nuova app, aggiunta l'app a INSTALLED_APPS ed eseguito syncdb:

django.core.exceptions.FieldError: Local field 'name' in class 'LongNamedRestaurant' clashes with field of similar name from base class 'Place'

Sembra che Django non lo supporti.

Questo fantastico pezzo di codice ti consente di "sovrascrivere" i campi nelle classi genitore astratte.

def AbstractClassWithoutFieldsNamed(cls, *excl):
    """
    Removes unwanted fields from abstract base classes.

    Usage::
    >>> from oscar.apps.address.abstract_models import AbstractBillingAddress

    >>> from koe.meta import AbstractClassWithoutFieldsNamed as without
    >>> class BillingAddress(without(AbstractBillingAddress, 'phone_number')):
    ...     pass
    """
    if cls._meta.abstract:
        remove_fields = [f for f in cls._meta.local_fields if f.name in excl]
        for f in remove_fields:
            cls._meta.local_fields.remove(f)
        return cls
    else:
        raise Exception("Not an abstract model")

Quando i campi sono stati rimossi dalla classe genitore astratta, sei libero di ridefinirli secondo le tue necessità.

Questo non è il mio lavoro. Codice originale da qui: https://gist.github.com/specialunderwear/9d917ddacf3547b646ba

Forse potresti occuparti di contrib_to_class:

class LongNamedRestaurant(Place):

    food_type = models.CharField(max_length=25)

    def __init__(self, *args, **kwargs):
        super(LongNamedRestaurant, self).__init__(*args, **kwargs)
        name = models.CharField(max_length=255)
        name.contribute_to_class(self, 'name')

Syncdb funziona bene. Non ho provato questo esempio, nel mio caso ho semplicemente sovrascritto un parametro di vincolo quindi ... aspetta e guarda!

So che è una vecchia domanda, ma ho avuto un problema simile e ho trovato una soluzione alternativa:

Ho seguito le seguenti classi:

class CommonInfo(models.Model):
    image = models.ImageField(blank=True, null=True, default="")

    class Meta:
        abstract = True

class Year(CommonInfo):
    year = models.IntegerField() 

Ma volevo che il campo immagine ereditato da Year fosse richiesto mantenendo il campo immagine della superclasse annullabile. Alla fine ho usato ModelForms per rinforzare l'immagine in fase di validazione:

class YearForm(ModelForm):
    class Meta:
        model = Year

    def clean(self):
        if not self.cleaned_data['image'] or len(self.cleaned_data['image'])==0:
            raise ValidationError("Please provide an image.")

        return self.cleaned_data

admin.py:

class YearAdmin(admin.ModelAdmin):
    form = YearForm

Sembra che questo sia applicabile solo per alcune situazioni (sicuramente dove è necessario applicare regole più rigide sul campo della sottoclasse).

In alternativa è possibile utilizzare il clean_<fieldname>()metodo invece di clean(), ad esempio, se townè necessario compilare un campo :

def clean_town(self):
    town = self.cleaned_data["town"]
    if not town or len(town) == 0:
        raise forms.ValidationError("Please enter a town")
    return town

Non è possibile sovrascrivere i campi del modello, ma è facilmente ottenibile sovrascrivendo / specificando il metodo clean (). Ho avuto il problema con il campo e-mail e volevo renderlo unico a livello di modello e l'ho fatto in questo modo:

def clean(self):
    """
    Make sure that email field is unique
    """
    if MyUser.objects.filter(email=self.email):
        raise ValidationError({'email': _('This email is already in use')})

Il messaggio di errore viene quindi catturato dal campo Modulo con il nome "email"

La mia soluzione è semplice come la prossima monkey patching, nota come ho cambiato il campo max_lengthdell'attributo fo namenel LongNamedRestaurantmodello:

class Place(models.Model):
   name = models.CharField(max_length=20)

class LongNamedRestaurant(Place):
    food_type = models.CharField(max_length=25)
    Place._meta.get_field('name').max_length = 255