的SQLAlchemy：檢索特定用戶

Question

我有用戶的favorite_series誰可以有他最喜歡的系列和存在具有系列作爲外鍵，我正在嘗試從最喜歡的系列的用戶的所有劇集集所有情節。 我用的燒瓶SQLAlchemy的。

數據庫：

db = SQLAlchemy(app) 

# cross table for user-series 
favorite_series = db.Table('favorite_series', 
    db.Column('user_id', db.Integer, db.ForeignKey('user.id')), 
    db.Column('series_id', db.Integer, db.ForeignKey('series.id')) 
) 

# user 
class User(db.Model): 
    __tablename__ = 'user' 
    id = db.Column(db.Integer, primary_key=True) 
    favorite_series = db.relationship('Series', secondary=favorite_series, 
     backref=db.backref('users', lazy='dynamic')) 

# series 
class Series(db.Model): 
    __tablename__ = 'series' 
    id = db.Column(db.Integer, primary_key=True) 

# episode 
class Episode(db.Model): 
    __tablename__ = 'episode' 
    id = db.Column(db.Integer, primary_key=True) 
    series_id = db.Column(db.Integer, db.ForeignKey('series.id')) 
    series = db.relationship('Series', 
     backref=db.backref('episodes', lazy='dynamic')) 

朋友幫我SQL

select user_id,series.name,episode.name from (favorite_series left join series on favorite_series.series_id = series.id) left join episode on episode.series_id = series.id where user_id=1; 

Altough，我希望它在SQLAlchemy的API，但不能設法得到它的工作。

編輯：

我的最終工作結果：

episodes = Episode.query.filter(Episode.series_id.in_(x.id for x in g.user.favorite_series)).filter(Episode.air_time!=None).order_by(Episode.air_time) 

Answer 1

首先你似乎並不被宣告你的表名？ 此外，與ORM困擾的整點，所以你再也不用寫SQL查詢：

from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy import orm 
import sqlalchemy as db 
Base = declarative_base() 

favorite_series = db.Table('favorite_series', Base.metadata, 
    db.Column('user_id', db.Integer, db.ForeignKey('User.id')), 
    db.Column('series_id', db.Integer, db.ForeignKey('Series.id')) 
) 
class Episode(Base): 
    __tablename__ = 'Episode' 
    id = db.Column(db.Integer, primary_key=True) 
    season = db.Column(db.Integer) 
    episode_num = db.Column(db.Integer) 
    series_id = db.Column(db.Integer, db.ForeignKey('Series.id')) 

    def __init__(self, season, episode_num, series_id): 
     self.season = season 
     self.episode_num = episode_num 
     self.series_id = series_id 

    def __repr__(self): 
     return self.series.title + \ 
       ' S' + str(self.season) + \ 
       'E' + str(self.episode_num) 

class Series(Base): 
    __tablename__ = 'Series' 
    id = db.Column(db.Integer, primary_key=True) 
    title = db.Column(db.String) 
    episodes = orm.relationship('Episode', backref='series') 

    def __init__(self, title): 
     self.title = title 

    def __repr__(self): 
     return self.title 

class User(Base): 
    __tablename__ = 'User' 
    id = db.Column(db.Integer, primary_key=True) 
    name = db.Column(db.String) 
    favorite_series = orm.relationship('Series', 
     secondary=favorite_series, backref='users') 

    def __init__(self, name): 
     self.name = name 

    def __repr__(self): 
     return self.name 

現在你可以只是讓你DB同步併發出訪問對象的屬性，讓SQL鍊金術交易查詢。

engine = db.create_engine('sqlite:///:memory:') 
session = orm.sessionmaker(bind=engine)() 
Base.metadata.create_all(engine) 

lt = User('Ludovic Tiako') 
the_wire = Series('The Wire') 
friends = Series('Friends') 
session.add_all([lt, the_wire, friends]) 
session.commit() # need to commit here to generate the id fields 

tw_s01e01 = Episode(1,1,the_wire.id) 
tw_s01e02 = Episode(1,2,the_wire.id) 
f_s01e01 = Episode(1,1,friends.id) 
f_s01e02 = Episode(1,2,friends.id) 
f_s01e03 = Episode(1,3,friends.id) 

session.add_all([tw_s01e01, tw_s01e02, 
       f_s01e01, f_s01e02, f_s01e03]) 
session.commit() 


the_wire.episodes # > [The Wire S1E1, The Wire S1E2] 
friends.episodes # > [Friends S1E1, Friends S1E2, Friends S1E3] 

最後，要回答你的問題：

lt.favorite_series.append(the_wire) 
session.commit() 
lt.favorite_series # > [The Wire] 
[s.episodes for s in lt.favorite_series] # >> [[The Wire S1E1, The Wire S1E2]] 

Answer 2

我不知道瓶中，但是從燒瓶的SQLAlchemy的文檔，似乎它使用的聲明，所以ORM 。所以，你應該有一個會議。我認爲它可以從db.session訪問。

無論如何，如果這些假設是真的，這是你應該怎麼做：

query = db.session.query(User.id, Series.name, Episode.name).filter((Episode.series_id == Series.id) & \ 
    (User.id == favorite_series.c.user_id) & (Series.id == favorite_series.c.id) & \ 
    (User.id == 1)) 
results = query.all(); 

它可能不是你所提供的準確的查詢，但也應該這樣做。

更新：我剛剛檢查了github燒瓶SQLAlchemy的代碼，似乎db是SQLAlchemy一個實例，其中有一個session屬性，通過self.session = self.create_scoped_session(session_options)它返回一個會話對象創建。所以這應該工作。

另外，不通過這樣做，你不會使用他們的BaseQuery，雖然我不知道是什麼，這將意味着......

檢查文檔，知道該怎麼做完全是。