SQL Alchemy interroger plusieurs tables

Question

J'essaie de faire une requête en utilisant l'alchimie SQL qui aurait été très simple si je n'utilisais pas ORM, donc je me dis qu'il y a sûrement un moyen simple. J'ai parcouru la plupart des questions sur ce sujet mais je ne semble pas répondre à ma question. J'ai ces deux tables

class Artisan(Base): 
    __tablename__ = 'artisan' 
    name = Column(String(80), nullable=False) 
    skill = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    category = Column(Integer, ForeignKey(Category.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    id_no = Column(Integer, nullable=False) 
    users = relationship(Users) 

et

class Address(Base): 
    __tablename__ = 'address' 
    building = Column(String(80), nullable=False) 
    floor = Column(String(80), nullable=False) 
    house_no = Column(String(80), nullable=False) 
    telephone = Column(String(80), nullable=False) 
    kwetu_address = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    lat = Column(String(25)) 
    lng = Column(String(25)) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

Je voudrais filtrer les artisans par une catégorie, puis filtrer les adresses par les artisans filtrés, et présenter les résultats d'une manière qui associe la artisan avec des adresses, espérons obtenir sqlalchemy faire le filtrage

respectifs le mieux que je peux venir avec implique deux requêtes et de post-traitement que je me sens est très inefficace

my_artisans = (session.query(Artisan).filter_by(category=cat_id)) 
my_addresses = (session.query(Address) 
         .join(Artisan, Artisan.id ==Address.artisan).filter_by(category=cat_id)) 
return jsonify(artisans =[art.serialize for art in my_artisans], addresses=[add.serialize for add in my_addresses]) 

Merci

Rajouter - toutes les classes liées

import sys 
from sqlalchemy import Column, ForeignKey, Integer, String, Float 
from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy.orm import relationship 
from sqlalchemy import create_engine 

Base = declarative_base() 


class Users(Base): 
    __tablename__ = 'users' 
    name = Column(String(80), nullable=False) 
    email = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    picture = Column(String(80)) 


class Category(Base): 
    __tablename__ = 'category' 
    name = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'name': self.name 
     } 


class Artisan(Base): 
    __tablename__ = 'artisan' 
    name = Column(String(80), nullable=False) 
    skill = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    category = Column(Integer, ForeignKey(Category.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    id_no = Column(Integer, nullable=False) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'name': self.name, 
      'skill': self.skill, 
      'category': self.category, 
      'bio': self.bio, 
      'id_no': self.id_no 

     } 


class Portfolio(Base): 
    __tablename__ = 'portfolio' 
    title = Column(String(80), nullable=False) 
    details = Column(String(300), nullable=False) 
    id = Column(Integer, primary_key=True) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'title': self.title, 
      'details': self.details 
     } 


class Endorsements(Base): 
    __tablename__ = 'endorsements' 
    title = Column(String(80), nullable=False) 
    details = Column(String(300), nullable=False) 
    id = Column(Integer, primary_key=True) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'title': self.title, 
      'details': self.details 
     } 


class Address(Base): 
    __tablename__ = 'address' 
    building = Column(String(80), nullable=False) 
    floor = Column(String(80), nullable=False) 
    house_no = Column(String(80), nullable=False) 
    telephone = Column(String(80), nullable=False) 
    kwetu_address = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    lat = Column(String(25)) 
    lng = Column(String(25)) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'lat': self.lat, 
      'lng': self.lng, 
      'kwetu_address': self.kwetu_address, 
      'artisan': self.artisan 
     } 


engine = create_engine('sqlite:///mycatalog.db') 

Base.metadata.create_all(engine) 

Answer 1

Cela m'a donné ce que je avais besoin en termes d'associer mon artisan avec des adresses respectives, bien que toujours en utilisant deux requêtes

my_artisans = (session.query(Artisan).filter_by(category=cat_id)) 
my_addresses = (session.query(Address) 
         .join(Artisan, Artisan.id ==Address.artisan).filter_by(category=cat_id)) 
these_addresses = [] 
for art in my_artisans: 
    art_id = art.id 
    for add in my_addresses: 
     if art_id == add.artisan: 
      grouped_address = {"Artisan Id" : art.id, "name" : art.name, "skill" : art.skill, "Lat" : add.lat, "lng" : add.lng} 
       these_addresses.append(grouped_address) 

    return jsonify({'Addresses': these_addresses })