SQLAlchemy与Select子查询协同工作

我正在尝试将以下SQL编写为SQLAlchemy查询：

SELECT COALESCE((
    SELECT client_id 
    FROM client_subclient_map m
    WHERE m.subclient_id = brands.client_id 
    LIMIT 1), 
    client_id)
FROM brands 
WHERE id = $1;

我目前拥有以下功能：

def client_subclient_map(self):
    return self.session.query(ClientSubclientMap).\
            filter(ClientSubclientMap.subclient_id==Brand.client_id).\
            limit(1).\
            subquery()

def top_client(self, brand_id):
    clientmap_alias = aliased(ClientSubclientMap, self.client_subclient_map())
    self.query = self.session.query(
                    func.coalesce(
                        clientmap_alias.client_id, Brand.client_id
                    )).\
                    filter(Brand.id==brand_id)
    print self.query
    return self

这将创建以下子查询：

SELECT client_subclient_map.client_id, client_subclient_map.subclient_id 
FROM client_subclient_map, brands 
WHERE client_subclient_map.subclient_id = brands.client_id
LIMIT :param_1

主要功能：

def client_subclient_map(self):
    return self.session.query(ClientSubclientMap).\
            filter(ClientSubclientMap.subclient_id==Brand.client_id).\
            limit(1).\
            subquery()

def top_client(self, brand_id):
    clientmap_alias = aliased(ClientSubclientMap, self.client_subclient_map())
    self.query = self.session.query(
                    func.coalesce(
                        clientmap_alias.client_id, Brand.client_id
                    )).\
                    filter(Brand.id==brand_id)
    print self.query
    return self

这将创建查询：

SELECT coalesce(:param_1, brands.client_id) AS coalesce_1 
FROM brands 
WHERE brands.id = :id_1

然后我就给你打电话

def get(self):
    return self.query.first()

组合时由my函数创建的完整查询如下所示：

SELECT coalesce(anon_1.client_id, brands.client_id) AS coalesce_1 
FROM (
    SELECT client_subclient_map.client_id AS client_id, 
        client_subclient_map.subclient_id AS subclient_id 
    FROM client_subclient_map, brands 
    WHERE client_subclient_map.subclient_id = brands.client_id
    LIMIT :param_1) AS anon_1, 
    brands 
WHERE brands.id = :id_1

这是错误的，因为select子查询发生在错误的位置，它需要发生在coalesce函数中，而不是在FROM子句中才能工作

我是SQLAlchemy的新手，所以在我的设置中，这可能也是一个问题。我确实在ClientSubclientMap表上的client_id和subclient_id列上都有ForeignKey引用，但两个外键引用同一列client.id时出现问题，因此我删除了ClientSubclientMap.client外键引用

sqlalchemy.exc.AmbiguousForeignKeysError: Could not determine join condition 
between parent/child tables on relationship ClientSubclientMap.subclients - 
there are multiple foreign key paths linking the tables.  Specify the 
'foreign_keys' argument, providing a list of those columns which should be 
counted as containing a foreign key reference to the parent table.

---

最后不得不将查询重写为

JOIN

，并使用

CASE

语句作为解决方法

def top_client(self, brand_id):
    self.query = self.session.query(case([(ClientSubclientMap.client_id==None, 
                                         Brand.client_id)],  
                                         else_=ClientSubclientMap.client_id))\
                    .outerjoin(ClientSubclientMap, 
                               Brand.client_id==ClientSubclientMap.subclient_id)\
                    .filter(Brand.id==brand_id)
    return self

它构造了查询：

SELECT 
    CASE 
        WHEN (client_subclient_map.client_id IS NULL) 
        THEN brands.client_id 
        ELSE client_subclient_map.client_id 
    END AS anon_1 
FROM brands 
    LEFT OUTER JOIN client_subclient_map 
        ON brands.client_id = client_subclient_map.subclient_id 
WHERE brands.id = :id_1

---

我仍然有兴趣知道如何在

COALESCE

函数中执行嵌套的

SELECT

语句，不过如果有人能提供帮助的话。

该错误消息与您上面演示的代码无关。在映射的某个地方，有一个名为“subclients”的关系连接到一个名为ClientSubclientMap的类，它需要更详细地了解如何连接到其目标类。找到该映射后，请参阅以了解有关如何解析的背景信息。