Question

我遇到过sqlite3和sqlalchemy的一些问题。从一段时间以来，我尝试进行一些特定的查询，并在某种程度上我失败了。数据库由两个表用户和Properties组成。这些表格如下图所示。

sqlite> .schema users
CREATE TABLE users (
    id INTEGER NOT NULL, 
    name VARCHAR(50) NOT NULL, 
    PRIMARY KEY (id)
);

sqlite> .schema properties
CREATE TABLE properties (
    id INTEGER NOT NULL, 
    property_number INTEGER, 
    user_id INTEGER, 
    PRIMARY KEY (id), 
    FOREIGN KEY(user_id) REFERENCES users (id)
);

用户表的内容非常简单，但属性值得一些解释。在property_number列中，我存储了不同的属性，每个属性都有唯一的编号，例如：property bald的编号为3，属性tan的编号为4等。如果User有多个属性，则每个属性都占用属性表中的一行。我选择这种风格是为了方便添加新属性，而不会搞乱迁移和类似的东西。

问题是，不知道如何进行包含多个属性的查询。我目前最好的解决方案是，在单独的查询中询问每个属性。这给出了mi的集合列表，两个不同的集合。一个用于给定属性的正面和一个用于负面实例（正面等于我希望用户拥有的东西，负面等于我不希望用户拥有的东西）。在下一步中，我将两个子集区分开来，并得到包含用户的最终列表。对我有兴趣的ids属性。然后我查询那些用户＆＃39;名。这似乎很复杂，也许是，但肯定是丑陋的。我也不喜欢对每个属性进行单一查询。如果somone感兴趣的Python代码。

def prop_dicts():
    """Create dictionaries of properties
    contained in table properties in db.

    Returns:
        touple:
            prop_names (dict)
            prom_values (dict)."""

    prop_names = {'higins': 10000,
                  'tall': 1,
                  'fat': 2,
                  'bald': 3,
                  'tan': 4,
                  'hairry': 5}
    prop_values = {1000: 'higins',
                   1: 'tal',
                   2: 'fat',
                   3: 'bald',
                   4: 'tan',
                   5: 'hairry'}
    dictionaries = (prop_names, prop_values)
    return dictionaries


 def list_of_sets_intersection(set_list):
    """Makes intersection of all sets in list.

    Args:
        param1 (list): list containing sets to check.

    Returns:
        set (values): contains intersectred values."""

    if not set_list:
        return set()
    result = set_list[0]
    for s in set_list[1:]:
        result &= s
    return result


def list_of_sets_union(set_list):
    """Makes union of elements in all sets in list.

    Args:
        param1 (list): list containing sets to check.

    Returns:
        set (values): contains union values."""

    if not set_list:
        return set()
    result = set_list[0]
    for s in set_list[1:]:
        result |= s
    return result


def db_search():
    """Search database against positiv and negative values.

    Returns:
        list (sets): one set in list for every property in
                     table properties db."""

    n, v = prop_dicts()

    positive = [2, 3]
    negative = [4, 5]
    results_p = []
    results_n = []

    #Positive properties.
    for element in xrange(0, len(positive)):
        subresult = []

        for u_id, in db.query(Property.user_id).\
                              filter_by(property_number = positive[element]):
            subresult.append(u_id)

        subresult = set(subresult)
        results_p.append(subresult)

    #Negative properties.
    for element in xrange(0, len(negative)):
        subresult = []

        for u_id, in db.query(Property.user_id).\
                              filter_by(property_number = negative[element]):
            subresult.append(u_id)

        subresult = set(subresult)
        results_n.append(subresult)

    print 'positive --> ', results_p
    print 'negative --> ', results_n

    results_p = list_of_sets_intersection(results_p)
    results_n = list_of_sets_union(results_n)

    print 'positive --> ', results_p
    print 'negative --> ', results_n

    final_result = results_p.difference(results_n)
    return list(final_result)


print db_search()

这是一种在单个查询中执行此操作的方法吗？我是数据库领域的新手，对不起，如果问题的质量似乎很蹩脚。有很多可能性，我真的不知道如何在＆＃34;右边＆＃34;办法。我已经搜索了大量关于这个主题的互联网，我找到的最佳解决方案是包含＆＃34; WHERE＆＃34;原因和＆＃34; AND＆＃34;操作员。但如果你连接一个表的两个相同的列，那么这两个不起作用。

SELECT user_id FROM properties WHERE property_number=3 AND property_number=4;

或者在sqlalchemy。

db.query(User.user_id).join(Property).filter(and_(property_number=3, property_number=4)).all()

此sqlalchemy示例可能包含一些错误，因为我没有预览，但您肯定会明白这是什么意思。

Answer 1

您可以使用聚合

来完成此操作

SELECT user_id
FROM properties
WHERE property_number in (3, 4)
GROUP BY user_id
HAVING count(*) = 2

在SQLAlchemy中

from sqlalchemy import func

properties = [3, 4]
db.session.query(Property.user_id)\
    .filter(Property.property_number.in_(properties))\
    .group_by(Property.user_id)\
    .having(func.count()==len(properties))\
    .all()

<强>更新

positive = [2, 3]
negative = [4, 5]

positive_query = db.session.query(Property.user_id)\
    .filter(Property.property_number.in_(positive))\
    .group_by(Property.user_id)\
    .having(func.count()==len(positive))

negative_query = db.session.query(Property.user_id)\
    .filter(Property.property_number.in_(negative))\
    .distinct()

final_result = positive_query.except_(negative_query).all()

Sqlalchemy单个查询一个表

1 个答案: