按照行顺序在多个字段中搜索

Question

我有一个如下的模型:

class Foo(models.Model):
    fruit = models.CharField(max_length=10)
    stuff = models.CharField(max_length=10)
    color = models.CharField(max_length=10)
    owner = models.CharField(max_length=20)
    exists = models.BooleanField()
    class Meta:
        unique_together = (('fruit', 'stuff', 'color'), )

它填充了一些数据：

fruit  stuff  color   owner  exists
Apple  Table   Blue     abc    True
 Pear   Book    Red     xyz   False
 Pear  Phone  Green     xyz   False
Apple  Phone   Blue     abc    True
 Pear  Table  Green     abc    True

我需要合并/加入一个集合（不是queryset）：

[('Apple', 'Table', 'Blue'), ('Pear', 'Phone', 'Green')]

所以基本上，当我用这个元组列表搜索这个模型时，第0行和第2行应该返回。

目前，我的解决方法是将 Foo.objects.all（） 读取到数据帧中，并与元组列表进行合并，并将 ID 传递给 Foo.objects.filter（）。我还尝试迭代列表并在每个元组上调用 Foo.object.get（），但它非常慢。这个清单相当大。

当我尝试按照当前答案的建议链接Q时，它抛出了一个OperationalError(太多SQL变量)。

我的主要目标如下：

从模型中可以看出，这三个字段共同构成了我的主键。该表包含大约15k个条目。当我从另一个来源获取数据时，我需要检查数据是否已经在我的表中，并相应地创建/更新/删除（新数据可能包含多达15k个条目）。有没有一种干净高效的方法来检查这些记录是否已经在我的表中？

注意：元组列表不必是那种形状。我可以修改它，将其转换为另一个数据结构或转置它。

Answer 1

这是正确的查询：

q = Foo.objects.filter(
    Q(fruit='Apple', stuff='Table', color='Blue') |
    Q(fruit='Pear', stuff='Phone', color='Green')
)

此查询也可以工作（如果您不喜欢Q）：

q = Foo.objects.filter(
    fruit='Apple', stuff='Table', color='Blue'
) | Foo.objects.filter(
    fruit='Pear', stuff='Phone', color='Green'
)

Answer 2

如果您知道这些字段构成了您的自然关键字，并且您必须对它们进行大量的查询，请将这个自然关键字添加为一个适当的字段，并采取措施来维护它:

class FooQuerySet(models.QuerySet):
    def bulk_create(self, objs, batch_size=None):
        objs = list(objs)
        for obj in objs:
            obj.natural_key = Foo.get_natural_key(obj.fruit, obj.stuff, obj.color)
        return super(FooQuerySet, self).bulk_create(objs, batch_size=batch_size)

    # you might override update(...) with proper F and Value expressions, 
    # but I assume the natural key does not change

class FooManager(models.Manager):
    def get_queryset(self):
        return FooQuerySet(self.model, using=self._db)

class Foo(models.Model):
    NK_SEP = '|||'  # sth unlikely to occur in the other fields

    fruit = models.CharField(max_length=10)
    stuff = models.CharField(max_length=10)
    color = models.CharField(max_length=10)
    natural_key = models.CharField(max_length=40, unique=True, db_index=True)

    @staticmethod
    def get_natural_key(*args):
        return Foo.NK_SEP.join(args) 

    def save(self, *args, **kwargs):
        self.natural_key = Foo.get_natural_key(self.fruit, self.stuff, self.color)
        Super(Foo, self).save(*args, **kwargs)

    objects = FooManager()

    class Meta:
        unique_together = (('fruit', 'stuff', 'color'), )

现在您可以查询:

from itertools import starmap

lst = [('Apple', 'Table', 'Blue'), ('Pear', 'Phone', 'Green')]
existing_foos = Foo.objects.filter(natural_key__in=list(starmap(Foo.get_natural_key, lst)))

并批量创建：

Foo.objects.bulk_create(
    [
        Foo(fruit=x[0], stuff=x[1], color=x[2]) 
        for x in lst 
        if x not in set(existing_foos.values_list('fruit', 'stuff', 'color'))
    ]
)

Answer 3

你有< code>('fruit '，' stuff '，' color')字段唯一在一起

因此，如果您的搜索元组是< code>('Apple '，' Table '，' Blue')并且我们连接它，那么它也将是一个唯一的字符串

f = [('Apple', 'Table', 'Blue'), ('Pear', 'Phone', 'Green')]
c = [''.join(w) for w in f]
# Output: ['AppleTableBlue', 'PearPhoneGreen']

因此，我们可以过滤注释上的查询集并利用 Concat。

Foo.objects.annotate(u_key=Concat('fruit', 'stuff', 'color', output_field=CharField())).filter(u_key__in=c)
# Output: <QuerySet [<Foo: #0row >, <Foo: #2row>]>

这将适用于元组和列表

如果输入是2元组列表:

[('Apple', 'Table', 'Blue'), ('Pear', 'Phone', 'Green')]

转置后输入将为：

transpose_input = [('Apple', 'Pear'), ('Table', 'Phone'), ('Blue', 'Green')]

我们可以通过统计each_tuple_size和input_list_size很容易地识别出输入是转置的。因此，我们可以使用zip再次转置它，上面的解决方案将按预期工作。

if each_tuple_size == 2 and input_list_size == 3:
    transpose_again = list(zip(*transpose_input))
    #  use *transpose_again* variable further

如果输入是 3 个元组的列表：

[('Apple', 'Table', 'Blue'), ('Pear', 'Phone', 'Green'), ('Pear', 'Book', 'Red')]

转置后输入将为：

transpose_input = [('Apple', 'Pear', 'Pear'), ('Table', 'Phone', 'Book'), ('Blue', 'Green', 'Red')]

因此，不可能确定每个＜code＞n*n