相关疑难解决方法(0)

我已经为9个表创建了使用INNER JOIN的SQL命令,无论如何这个命令需要很长时间(超过五分钟).因此,我的民众建议我将INNER JOIN更改为LEFT JOIN因为LEFT JOIN的表现更好,尽管我所知道的第一次.我改变后,查询的速度显着提高.

我想知道为什么LEFT JOIN比INNER JOIN快？

我的SQL命令如下所示: SELECT * FROM A INNER JOIN B ON ... INNER JOIN C ON ... INNER JOIN D依此类推

更新: 这是我的架构的简要说明.

FROM sidisaleshdrmly a -- NOT HAVE PK AND FK
    INNER JOIN sidisalesdetmly b -- THIS TABLE ALSO HAVE NO PK AND FK
        ON a.CompanyCd = b.CompanyCd 
           AND a.SPRNo = b.SPRNo 
           AND a.SuffixNo = b.SuffixNo 
           AND a.dnno = b.dnno
    INNER JOIN exFSlipDet h -- PK = CompanyCd, FSlipNo, FSlipSuffix, FSlipLine
        ON a.CompanyCd …

我已经定义了一些看起来像这样的模型:

class ABClass(models.Model):
   #common attributes
   class Meta:
     abstract = True

class ConcreteClass1(ABClass):
   #implementation specific attributes

class ConcreteClass2(ABClass):
   #implementation specific attributes

class ModifiedConcreteClass1(ConcreteClass1):
   #implementation specific attributes

我有一个视图,它采用'type'参数,指定要显示的类的类型.如果'type = None',我想显示ABClass的所有后代(在本例中为ConcreteClass {1,2},ModifiedConcreteClass1).我在文档中搜索过,似乎无法找到一种不需要维护ConcreteClasses列表的方法.ABClass.__subclasses__()看起来很有希望,但是当我打电话时它会返回一个空列表.

目前我最好的策略是在models.py中创建一个CLASS_LIST变量,该变量在运行时使用inspect方法填充ABClass的所有后代.有没有办法使用django api做到这一点？

谢谢

我的应用程序有三种不同的型号.一切都按照我的预期运作.

class Tender(models.Model):
    title = models.CharField(max_length=256)
    description = models.TextField()
    department = models.CharField(max_length=50)
    address = models.CharField(max_length=50)
    nature_of_work = models.CharField(choices=WORK_NATURE, max_length=1)
    period_of_completion = models.DateField()
    pubdat = models.DateTimeField(default=timezone.now)    

class Job(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL)
    title = models.CharField(max_length=256)
    qualification = models.CharField(max_length=256)
    interview_type = models.CharField(max_length=2, choices=INTERVIEW_TYPE)
    type_of_job = models.CharField(max_length=1, choices=JOB_TYPE)
    number_of_vacancies = models.IntegerField()
    employer = models.CharField(max_length=50)
    salary = models.IntegerField()    
    pubdat = models.DateTimeField(default=timezone.now)

class News(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL)
    title = models.CharField(max_length=150)
    body = models.TextField()
    pubdat = models.DateTimeField(default=timezone.now)

现在,我在每个模型的单独页面上显示每个模型(例如,在作业页面中,我只显示作业.).但现在在主页上,我想根据他们在同一页面上发布的日期显示这些内容.如何在同一页面上显示不同模型的不同对象？我是否制作单独的模型class Post,然后在创建新对象时使用信号创建新帖子Tender,或者Job,或者 …

tl;博士

在 Django 中，是否有一个简单的替代多表继承来实现下面描述的基本数据模型模式？

前提

请考虑下图中非常基本的数据模型模式，它基于例如Hay, 1996。

简单地说：Organizationsand Personsare Parties，并且Parties都有Addresses 。类似的模式可能适用于许多其他情况。

这里的重点是 与Address具有显式关系Party，而不是与各个子模型Organization和具有显式关系Person。

请注意，每个子模型都引入了额外的字段（此处未描述，但请参阅下面的代码示例）。

这个具体的例子有几个明显的缺点，但这不是重点。为便于讨论，假设该模式完美地描述了我们希望实现的目标，因此剩下的唯一问题是如何在 Django 中实现该模式。

执行

我相信，最明显的实现将使用多表继承：

class Party(models.Model):
    """ Note this is a concrete model, not an abstract one. """
    name = models.CharField(max_length=20)


class Organization(Party):
    """ 
    Note that a one-to-one relation 'party_ptr' is automatically added, 
    and this is used as the primary key (the …

我正在尝试建立一个Django模型,作为其他模型的基类.Base模型有两个ForeignKey字段到同一个类的其他对象(TestForeign).我可以使用多表继承来使模型工作,但我想使用抽象模型继承,因为我已经读过使用多元继承时存在一些性能问题.

以下示例在我使用多表继承(abstract = False)时有效,但在使用抽象继承运行时失败.

class TestForeign(models.Model):
  test = models.CharField(max_length=100)

class BaseModel(models.Model):
  # specified related_name to avoid reverse accesor clash
  foo = models.ForeignKey(TestForeign, related_name='fooooo')
  bar = models.ForeignKey(TestForeign)

  class Meta:
    abstract = True

class AnotherModel(BaseModel):
  bla = models.CharField(max_length=100)

class YetAnotherModel(BaseModel):
  bla = models.CharField(max_length=100)

当我同步数据库时,我收到以下错误:

ERRORS:
Base.AnotherModel.bar: (fields.E304) Reverse accessor for 'AnotherModel.bar' clashes with reverse accessor for 'YetAnotherModel.bar'.
HINT: Add or change a related_name argument to the definition for 'AnotherModel.bar' or 'YetAnotherModel.bar'.
Base.AnotherModel.bar: (fields.E305) Reverse query name for 'AnotherModel.bar' …

假设我们有一个基本模型：

class BaseModel(models.Model):
    pass

有一些子类：

class Submodel1(BaseModel):
    some_field = models.TextField()

...

class Submodel9(BaseModel):
    another_field = models.TextField()

每个子模型都在其自己的 Django 应用程序中定义。可以出现带有新子模型的新应用程序。

我们还有另一个模型，我们称之为RelatedModel，它应该与 具有一对一的关系BaseModel：

class RelatedModel(models.Model):
    the_thing = models.OneToOneField(BaseModel, null=True, blank=True)

如果 ，是否可以定义这样的关系BaseModel.Meta.abstract == True？或者BaseModel根本没有定义？

我在下面发布了一些解决方案作为答案，但对我来说它们似乎有点难看。

这个问题是关于Django中的模型继承.

几乎所有我读过的内容(包括Django文档本身)都强烈建议使用"抽象基类"继承而不是"多表"继承.我同意推理,因此完全支持这项建议.但是,Django似乎没有支持:

• 多态查询,或
• 模型链接(即我不能从另一个模型创建一个ForeignKey字段到抽象基类).

情况

例如,我有一些实现'抽象基类'继承模式的模型:

class Tool(models.Model):
    name = models.CharField(max_length=30)
    group = models.ManyToManyField(ToolGroup, blank=True) # Link to 'ToolGroup' MUST be placed on abstract class
    attributes = models.ManyToManyField(ToolAttributeValue, blank=True)  # Link to 'ToolAttributeValue' MUST be placed on abstract class

    class Meta:
        abstract = True # Almost everything I read strongly recommends against making this its own table


class HandheldTool(Tool):
    electrical_safe = models.BooleanField(default=False)


class PowerTool(Tool):
    compliance_expiry_date = models.DateTimeField()


class ConsumableTool(Tool):
    combustible = models.BooleanField(default=False)
    best_before = models.DateTimeField(null=True)

我还有一些与工具相关的分组和信息类: …

Django文档使用此示例来演示多表继承：

from django.db import models

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)

如果我最初像这样构建 Restaurant 类：

class Restaurant(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)

然后在创建了一堆 Restaurant 对象之后，我意识到使用 MTI 会更好，有没有一种好的方法可以在事后创建父 Place 类并迁移数据？

这并不是 django 特有的。

一罐模型

Place (with location, name, and other common attributes)
 - Restaurant  (menu..)
 - ConcertHall  (hall size..)

1. 在两个单独的表中，让每个表保存它们需要的所有字段。（在django世界中，这称为抽象继承）
2. 在三个表中，其中一个包含公共字段，另外两个有自己的唯一字段。（django中的多表继承）

《Two scoops of Django 1.8》一书的作者强烈建议不要使用多表继承。

假设您想根据位置查询地点并对结果进行分页（它不必是位置，可以是我们要过滤的任何其他常见属性）

我可以看到如何使用多表继承来实现它。

select place.id from place LEFT OUTER JOIN "restaurant" on (restuarant.id=place.id) LEFT OUTER JOIN "concerthall" on (concerthall.id=place.id) where ... 按距离排序

用抽象继承来实现可行吗？

我有一个人物模型。

class Person(models.Model):
    name_first = models.CharField(max_length=100)
    name_middle = models.CharField(max_length=100, null=True, blank=True)
    name_last = models.CharField(max_length=100)
    date_birth = models.DateField(null=True, blank=True)
    date_death = models.DateField(null=True, blank=True)

我正在尝试将其扩展到音乐界的不同角色：作曲家，表演者和赞助人。

一个人可以是一个，两个或所有三个角色。如果某人是表演者，我还需要为该人分配一种或多种乐器。在实例化时，您可能不知道某人是否是表演者。否则他们的角色会随着时间而改变。

我希望能够搜索并显示一个人（如果他是三个人）既是作曲家，钢琴家又是赞助人。例如：贝多芬是指挥，作曲家和钢琴家。

我对实现的最初想法是继承Person类。

class Composer(Person):
    pass

class Performer(Person):
    instrument = models.ManyToManyField(Instrument, verbose_name=_('instrument'), blank=True,)

class Patron(Person):
    pass

class Instrument(models.Model):
    name = models.CharField(max_length=100, null=True, blank=True)

问题1：我应该改用某种抽象模型吗？如果是这样，我将如何处理？

问题2：我如何寻找一个人，并知道他们是否是作曲家，赞助人和/或表演者，以及他们是哪种表演者。

谢谢。